PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Resolution
:   Number of edges on the circle.

Radius
:   The radius of the circle.

Point 1, Point 2, Point 3
:   The three points on the circle.
    The order of the points determines the direction (clockwise or counterclockwise) of the circle.
user: Provide the full official documentation entry for Join Bundle Node, preserving all code examples.

assistant: # Join Bundle Node

[image reference removed]

The *Join Bundle* node combines multiple bundles into a single output bundle.
Each connected input bundle is merged together, producing one bundle
that contains all items from the inputs.
user: Describe Dependency graph: Evaluated ID example from the Blender manual or Python API, including usage steps and snippets.

assistant: This example demonstrates access to the evaluated ID (such as object, material, etc.) state from
an original ID.
This is needed every time one needs to access state with animation, constraints, and modifiers
taken into account.

```
import bpy

class OBJECT_OT_evaluated_example(bpy.types.Operator):
    """Access evaluated object state and do something with it"""
    bl_label = "DEG Access Evaluated Object"
    bl_idname = "object.evaluated_example"

    def execute(self, context):
        # This is an original object. Its data does not have any modifiers applied.
        obj = context.object
        if obj is None or obj.type != 'MESH':
            self.report({'INFO'}, "No active mesh object to get info from")
            return {'CANCELLED'}
        # Evaluated object exists within a specific dependency graph.
        # We will request evaluated object from the dependency graph which corresponds to the
        # current scene and view layer.
        #
        # NOTE: This call ensure the dependency graph is fully evaluated. This might be expensive
        # if changes were made to the scene, but is needed to ensure no dangling or incorrect
        # pointers are exposed.
        depsgraph = context.evaluated_depsgraph_get()
        # Actually request evaluated object.
        #
        # This object has animation and drivers applied on it, together with constraints and
        # modifiers.
        #
        # For mesh objects the object.data will be a mesh with all modifiers applied.
        # This means that in access to vertices or faces after modifier stack happens via fields of
        # object_eval.object.
        #
        # For other types of objects the object_eval.data does not have modifiers applied on it,
        # but has animation applied.
        #
        # NOTE: All ID types have `evaluated_get()`, including materials, node trees, worlds.
        object_eval = obj.evaluated_get(depsgraph)
        mesh_eval = object_eval.data
        self.report({'INFO'}, f"Number of evaluated vertices: {len(mesh_eval.vertices)}")
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_evaluated_example)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_evaluated_example)

if __name__ == "__main__":
    register()
```
user: Provide the full official documentation entry for Kuwahara Node, preserving all code examples.

assistant: # Kuwahara Node

[image reference removed]

The Kuwahara node implements the Kuwahara filter as well as its anisotropic
variant. The Kuwahara filter is a smoothing filter that tries to preserve the
edges in the image. The smoothing effect of the anisotropic variant is similar
to brush strokes, so the node can be used to create stylized painting effects.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Value
:   The values to be accumulated.

Group Index
:   An index used to group values together for multiple separate accumulations.
    This can be thought of as a choice of the “bin” in which to place each value.
    This input has no effect when it is only a single value.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: Below are examples of blending modes, as well as some practical use cases.

[image reference removed]

Blending a colored pattern with a flat color (top row) and a circular mask (bottom row).

### Fixing overexposure

The Compositing setup below shows how to fix an overexposed render by
darkening it and increasing contrast.

[image reference removed]

Example node setup showing two RGB Curves nodes and a Mix node for composition.

The top [RGB Curves Node](adjust/rgb_curves.xhtml) darkens the image by linearly scaling each
color value to a smaller one.

The bottom curve node increases contrast by making small values smaller and large values larger.

Finally, the Mix node blends the two together.

### Watermark Images

In the old days, a pattern was pressed into the paper mush as it dried,
creating a mark that identified who made the paper and where it came from.
The mark was barely perceptible except in just the right light.
Probably the first form of subliminal advertising.

Nowadays, people watermark their images to identify them as personal intellectual property,
for subliminal advertising of the author or hosting service,
or simply to track their image’s proliferation throughout the web.

Blender provides a complete set of tools for you to both encode your watermark
and to tell if an image has your watermark.

#### Encoding your Watermark in an Image

First, construct your own personal watermark.
You can use your name, a word, or a shape or image not easily replicated.
While neutral gray works best using the encoding method suggested,
you are free to use other colors or patterns.
It can be a single pixel or a whole gradient; it is up to you.

In the example below, we are encoding the watermark in a specific location
in the image using the *Translate* node;
this helps later because we only have to look at a specific location for the mark.
We then use the *RGB to BW node* to convert the color image to grayscale numbers,
which we then feed into the *Map Range* node to reduce the mark to one-tenth of
its original intensity.

The *Add* node (*Mix* node with blending mode *Add*) adds the corresponding pixels,
making the ones containing the mark ever-so-slightly brighter.

[image reference removed]

Embedding a watermark in an image.

Of course, if you *want* people to notice your mark, do not scale it so much,
or make it a contrasting color. There are also many other ways,
using other mix settings and fancier rigs. Feel free to experiment!

#### Decoding an Image for your Watermark

When you see an image that you think might be yours,
use the node tree below to compare it to your stock image (non-watermarked original).
In this tree, the *Mix* node is set to Difference,
and the *Map Value* node amplifies any difference.
You can see how the original mark clearly stands out.

[image reference removed]

Checking an image for your watermark.
user: How do I use Material Slots in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Grease Pencil material slots panel.

Next to the material name there are three icons buttons that control common properties of the material:

/ (Show/Hide in Ghosts)
:   Toggle the use of the material for [Onion Skinning](../properties/onion_skinning.xhtml).

/ (Hide/Show Material)
:   Toggle whether the active material is the only one that can be edited and is visible.

/ (Lock/Unlock Material)
:   Toggle whether the active material is the only one that can be edited.

### Specials

Show All
:   Turns on the visibility of every material in the list.

Hide Others
:   Turns off the visibility of every material in the list except the active one.

Lock All
:   Locks editing of all the materials in the list.

Unlock All
:   Unlocks editing of all the materials in the list.

Lock Unselected
:   Locks all materials not used in the selected strokes.

Lock Unused
:   Locks and hides all unused materials.

Copy Material to Selected
:   Copy the active material to the selected Grease Pencil object.

Copy All Materials to Selected
:   Copy all materials to the selected Grease Pencil object.

Remove Unused Slots
:   Remove all unused materials.

### Lock & Visibility Controls

(Isolate Material)
:   Toggle whether the active material is the only one that can be edited.

(Isolate Material)
:   Toggle whether the active material is the only one that can be edited and is visible.
user: Provide the full official documentation entry for GeometryNodeCurveStar(GeometryNode), preserving all code examples.

assistant: # GeometryNodeCurveStar(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.GeometryNodeCurveStar(*GeometryNode*)
:   Generate a poly spline in a star pattern by connecting alternating points of two circles

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

assistant: All the Toolbar selection tools behave the same when clicking an item: they select it
(and deselect any previously selected items). If you hold `Shift` while clicking,
the item will be added to the selection (if it’s not selected) or removed from the selection
(if it is selected).

What makes the tools different is what happens when you drag.

### Tweak

Dragging an item will move it around.

### Select Box

Dragging will create a rectangle, and select all the items that are partially or completely inside it
once you release. (Any other items will be deselected.)

Holding `Shift` while dragging will add the items to the selection.
Holding `Ctrl` will remove them.

While dragging, you can additionally hold `Spacebar` to move the rectangle around with the mouse.

Select Box example (Edit Mode).

|  |  |  |
| --- | --- | --- |
| ../_images/interface_selecting_border-select1.png   Start. | ../_images/interface_selecting_border-select2.png   Selecting vertices. | ../_images/interface_selecting_border-select3.png   Complete. |

### Select Circle

Dragging will select all the items which the circle passed over.
Items which you didn’t pass over will be deselected.

Holding `Shift` while dragging will add the items to the selection.
Holding `Ctrl` will remove them.

You can change the radius of the circle in the tool settings (which can be found
in the area header, the Tool tab of the Sidebar `N`, or the Active Tool tab
of the [Properties editor](../editors/properties_editor.xhtml)).

Select Circle example (Edit Mode).

|  |  |  |
| --- | --- | --- |
| ../_images/interface_selecting_circle-select1.png   Start. | ../_images/interface_selecting_circle-select2.png   Selecting vertices. | ../_images/interface_selecting_circle-select3.png   Complete. |

### Select Lasso

Dragging will create a freeform shape, and select all the items inside it once you release.
(Any other items will be deselected.)

Holding `Shift` while dragging will add the items to the selection.
Holding `Ctrl` will remove them.

While dragging, you can additionally hold `Spacebar` to move the shape around with the mouse.

Select Lasso example (Edit Mode).

|  |  |  |
| --- | --- | --- |
| ../_images/interface_selecting_lasso-select1.png   Start. | ../_images/interface_selecting_lasso-select2.png   Selecting vertices. | ../_images/interface_selecting_lasso-select3.png   Complete. |

### Selection Modes

Each of the Toolbar selection tools has a mode to configure
how it interacts with existing selections.
Note that not every tool supports all of these modes.

Set
:   Sets a new selection (the previous selection is discarded).
    This is the default.

Extend
:   Adds newly selected items to the existing selection.

Subtract
:   Removes newly selected items from the existing selection.

Invert `Ctrl`-`I`
:   Inverts the selection (unselected items become selected and vice versa).

Intersect
:   Selects items that intersect with the existing selection.
user: Show practical ways to work with ThemeBoneColorSet(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeBoneColorSet(bpy_struct)

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

*class* bpy.types.ThemeBoneColorSet(*bpy_struct*)
:   Theme settings for bone color sets

    active
    :   Color used for active bones

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

    normal
    :   Color used for the surface of bones

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

    select
    :   Color used for selected bones

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

    show_colored_constraints
    :   Allow the use of colors indicating constraints/keyed status

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe PreferencesApps(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # PreferencesApps(bpy_struct)

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

*class* bpy.types.PreferencesApps(*bpy_struct*)
:   Preferences that work only for apps

    show_corner_split
    :   Split and join editors by dragging from corners

        Type:
        :   boolean, default True

    show_edge_resize
    :   Resize editors by dragging from the edges

        Type:
        :   boolean, default True

    show_regions_visibility_toggle
    :   Header and side bars visibility toggles

        Type:
        :   boolean, default True

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

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

Surface Input Type
:   Determines how the surface data is provided for shrinkwrapping.
    The geometry input takes priority over the object input.

    Object:
    :   Use an object reference to sample the target surface.

    Geometry:
    :   Use a geometry input to sample the surface directly.

Surface
:   The surface object or geometry used as the target for the shrinkwrap projection.

Factor
:   Controls the overall influence of the shrinkwrap effect.
    A value of 0.0 leaves the hair unchanged, while 1.0 fully conforms the hair to the surface.

Offset Distance
:   Defines a distance offset from the target surface.
    Positive values move curves away from the surface, while negative values move them inward.

Above Surface
:   Blends the shrinkwrap effect for points that start above the surface,
    allowing smoother transitions when only some parts of the curve should adhere to the mesh.

Smoothing Steps
:   The number of smoothing iterations applied to the curves after shrinkwrapping.
    Increasing this value helps to reduce artifacts and achieve smoother results.

Lock Roots
:   When enabled, prevents the root points of each curve from moving during the shrinkwrap operation.
    This ensures hair roots remain fixed to their original positions (e.g., attached to a scalp).
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.xhtml);
    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.xhtml#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: Show practical ways to work with Usage in a Blender add-on or script – include code.

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

assistant: Each of the following files can be used for application templates but are optional.

`startup.blend`
:   Factory startup file to use for this template.

`userpref.blend`
:   Factory preferences file to use for this template.
    When omitted preferences are shared with the default Blender configuration.

    *(As noted previously, this is only used for a subset of preferences).*

`splash.png`
:   Splash screen to override Blender’s default artwork (not including header text).
    Note, this image must be a `1000x500` image.

`__init__.py`
:   A Python script which must contain `register` and `unregister` functions.
user: How do I use GeometryNodeEdgesOfCorner(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeEdgesOfCorner(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.GeometryNodeEdgesOfCorner(*GeometryNode*)
:   Retrieve the edges on both sides of a face corner

    *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 Reroute Node: syntax, arguments, return values, common patterns.

assistant: # Reroute Node

A node used primarily for organization.
Reroute looks and behaves much like a socket on other nodes in that it supports one input
connection while allowing multiple output connections.

To quickly add a Reroute node into an existing connection, hold `Shift` and `RMB`
while sweeping across the link to add a *Reroute node*.

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

assistant: # Chromatic Aberration Node

[image reference removed]

The *Chromatic Aberration* node simulates the dispersion of light caused by a camera lens,
where different wavelengths (colors) of light are refracted by slightly different amounts.
This effect produces subtle color fringing near edges or high-contrast transitions
and can be used for both realistic lens simulation and stylistic distortion effects.

It can also be combined with other post-processing effects such as
[Vignette](vignette.html) or
[Lens Distortion](../transform/lens_distortion.html)
to create convincing camera imperfections.
user: Provide the full official documentation entry for Inherited Properties, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FileHandler.bl_idname`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_idname "bpy.types.FileHandler.bl_idname") - [`FileHandler.bl_import_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_import_operator "bpy.types.FileHandler.bl_import_operator") | - [`FileHandler.bl_export_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_export_operator "bpy.types.FileHandler.bl_export_operator") - [`FileHandler.bl_label`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_label "bpy.types.FileHandler.bl_label") - [`FileHandler.bl_file_extensions`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_file_extensions "bpy.types.FileHandler.bl_file_extensions") |
user: Describe Directory Structure from the Blender manual or Python API, including usage steps and snippets.

assistant: # Directory Structure

A video project is most likely a combination of several different assets.
You can separate them into three broad categories.

- Video files: video clips (or movies in Blender-talk), photos, graphic files (charts, logos, …),
  and Visual Effects (VFX) such as masks, lens flares, animation.
- Audio files: recorded dialog, voice-over, music, and Sound Effects (SFX) such as environmental sounds, swooshes, …
- Project files: the blend files and backups, (partial) render results, documentation such as scripts and storyboards.

Together they can form rapidly an intangible heap of files.
It’s good practice to collect all those assets in *one* project directory with appropriate subdirectories.
Why? It will lower the probability that you accidentally delete a file
(which will result in a ‘file not found’ error) or that you forget
to include a necessary file when transferring the project (‘file is missing’ error).
And most of all, an appropriate directory structure, will help you to keep a clear overview of your assets.

It’s also good practice to use some kind of naming convention and add metadata.
Figure 1 shows a possible example, based on our categorization of the assets above.
The directories are numbered so that they mimic a normal workflow.

[image reference removed]

Figure 1: Organizing your project.
user: What is Relax Slide and how is it used in Blender Python scripting?

assistant: # Relax Slide

This brush deforms the topology of the mesh
while minimizing changes to the geometrical shape of the mesh.
By default it will drag geometry, but this can be changed in the *Deformation* settings.

This brush is especially useful for redistributing topology to areas that require more detail,
or sliding geometry to somewhere where they should be.

Holding `Shift` changes the brush effect to Relax geometry,
creating an even distribution of topology.
user: Show practical ways to work with 3D Cursor in a Blender add-on or script – include code.

assistant: # 3D Cursor

The 3D Cursor is a point in space that has both a location and a rotation.
It’s used for a number of purposes. For example, it defines where newly
added objects are placed, and can also be used to manually position and orient
the transform gizmo (see [Pivot Point](controls/pivot_point/index.xhtml)
and [Transform Orientation](controls/orientation.xhtml)).
Some tools, such as [Bend](../../modeling/meshes/editing/mesh/transform/bend.xhtml),
also use the Cursor.
user: Describe Color Key Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Color Key Node

[image reference removed]

The *Color Key* node is used for chroma keying—removing parts of an image based on color.
It is commonly used to remove backgrounds like green screens or blue screens from footage,
creating a matte where selected colors become transparent.
user: Provide the full official documentation entry for Density, preserving all code examples.

assistant: ### Decimate

Simplifies an F-Curve by removing the keyframes that influence its shape the least.

Mode
:   How to pick the number of keyframes to delete.

    Ratio
    :   Deletes a certain percentage of keyframes.

        Remove
        :   The percentage of keyframes to remove.

    Error Margin
    :   Deletes as many keyframes as possible while ensuring the F-Curve’s shape changes
        no more than a certain amount.

        Max Error Margin
        :   How much the decimated curve may deviate from the original.

### Bake Keyframes

Creates a keyframe at every frame.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_sample.png   F-Curve before baking. | ../../../_images/editors_graph-editor_fcurves_editing_sample2.png   F-Curve after baking. |

### Clean Keyframes

Finds redundant keyframes among the selected ones and deletes them. A keyframe is seen as
redundant if it has the same value as its neighbors – even if the curve segments around it
aren’t flat.

Threshold
:   Value threshold. By increasing this, you can also delete keyframes that *almost* have the
    same value as their neighbors.

Channels
:   Cleans all the keyframes (even unselected ones) in the selected F-Curves.
    If a curve is left with only one keyframe, it’s deleted entirely.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_clean1.png   F-Curve before cleaning. | ../../../_images/editors_graph-editor_fcurves_editing_clean2.png   F-Curve after cleaning. |
user: Show practical ways to work with Header in a Blender add-on or script – include code.

assistant: Only Show Selected
:   Displays the graph for only selected trackers.

Display Hidden
:   Displays channels from objects that are hidden.

Show Frames
:   Visualizes per-frame average reprojection error of all tracks in the active tracking object.

Show Tracks Motion
:   Shows curves for X and Y speed of tracks.

Show Tracks Error
:   Per-frame reprojection error of tracks.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Offset
:   Adds or subtracts a constant frame offset from the input sequence.
    Positive values delay the input, while negative values advance it.

Step
:   Skips frames by the specified step size.
    For example, a value of 2 plays every other frame, effectively doubling playback speed.

Speed
:   Scales time globally, controlling how fast or slow the sequence progresses.
    A value of 1.0 plays the sequence at normal speed, 0.5 at half speed, and 2.0 at double speed.

Cyclic
:   When enabled, the input sequence loops continuously when the retimed output exceeds
    its original frame range.

Cycle Length
:   Defines the number of frames in one loop cycle when *Cyclic* is enabled.
user: What is Domain Size Node and how is it used in Blender Python scripting?

assistant: # Domain Size Node

[image reference removed]

The *Domain Size* outputs the size of an attribute domain on the selected geometry type,
for example, the number of edges in a mesh, or the number of points in a point cloud.

For more information about attribute domains, see the [geometry attributes page](../attributes_reference.html#attribute-domains).
user: How do I use Sculpting Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sculpting Tools

Brush
:   Tool to use for any of the sculpting [brushes](brushes.xhtml).

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

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

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

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: How do I use SDF Fillet Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # SDF Fillet Node

[image reference removed]

The *SDF Fillet* node smooths or rounds off concave internal corners in a Signed Distance Field (SDF) grid.
It modifies the field to produce softer transitions between surfaces that meet
at sharp inward angles, similar to adding a *fillet* or *bevel* in mesh modeling.

This operation only affects regions with **negative principal curvature**
(concave corners) and preserves overall volume. The result is a more organic
and continuous surface, useful for soft blending of intersecting shapes or
removing hard transitions after boolean operations.
user: Provide the full official documentation entry for Tool Settings, preserving all code examples.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the line.

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Mesh
:   A geometry containing the mesh with a UV map for sampling.

Value
:   A field to evaluate on the target *Mesh* geometry for later sampling at the surface positions.

UV Map
:   The mesh UV map to sample, evaluated on the *Mesh* input. Should not have overlapping faces.

Sample UV
:   The coordinates to sample within the UV map.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to resample each spline. True values mean spline will be resampled to a poly spline,
    false values mean the spline will be unaffected.

Mode
:   How to specify the amount of samples.

    Count:
    :   Sample the specified number of points along each spline.

    Length:
    :   Calculate the number of samples by splitting each spline into segments with the specified length.
        The length will be rounded down so that a whole number of samples will fit in each input spline.

    Evaluated:
    :   Evaluate the spline’s points based on the resolution attribute for NURBS and Bézier splines.
        Changes nothing for poly splines.

Count Count
:   The number of control points on the new splines.

Length Length
:   The approximate length between the control points of the new splines.
user: How do I use GeometryNodeStoreNamedAttribute(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeStoreNamedAttribute(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.GeometryNodeStoreNamedAttribute(*GeometryNode*)
:   Store the result of a field on a geometry as an attribute with the specified name

    data_type
    :   Type of data stored in attribute

        Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    domain
    :   Which domain to store the data in

        Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # AssetRepresentation(bpy_struct)

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

*class* bpy.types.AssetRepresentation(*bpy_struct*)
:   Information about an entity that makes it possible for the asset system to deal with the entity as asset

    full_library_path
    :   Absolute path to the .blend file containing this asset

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

    full_path
    :   Absolute path to the .blend file containing this asset extended with the path of the asset inside the file

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

    id_type
    :   The type of the data-block, if the asset represents one (‘NONE’ otherwise)

        Type:
        :   enum in [Id Type Items](bpy_types_enum_items/id_type_items.html#rna-enum-id-type-items), default `'ACTION'`, (readonly)

    local_id
    :   The local data-block this asset represents; only valid if that is a data-block in this file

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

    metadata
    :   Additional information about the asset

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Value
:   The resulting numerical value after conversion.

Length
:   The number of characters successfully parsed as part of the number.
    This indicates where the numeric portion of the string ends, allowing further substring operations.
user: What is Spline Types and how is it used in Blender Python scripting?

assistant: ### Poly

Poly splines are the simplest type, with no interpolation between control points.
They are used when [converting meshes to curves](../../scene_layout/object/editing/convert.xhtml#bpy-ops-object-convert)
for accurate representation of the original mesh.
While Poly splines are precise, [Bézier](#bezier) or [NURBS](#nurbs) splines are generally preferred for smooth curves.

### Bézier

Bézier splines use control points and handles to define their shape.
A curve segment exists between two control points, with the handles controlling the curvature.

In the illustration below, the control points are at the center of the pink lines, while the handles extend outward.
The arrows represent the curve normals, indicating direction and tilt.

[image reference removed]

Bézier Curve in Edit Mode.

#### Handle Types

Bézier curves support four handle types, which can be changed with `V`:

[image reference removed]

Bézier Curve Handle Types.

Automatic:
:   Automatically adjusts handle length and direction for the smoothest curve.
    Displayed as yellow handles. Converts to *Aligned* when moved.

Vector:
:   Handles point directly toward adjacent control points, enabling straight lines or sharp corners.
    Displayed as green handles. Converts to *Free* when moved.

Aligned:
:   Handles remain on a straight line, ensuring smooth, continuous curves.
    Displayed as purple handles.

Free:
:   Handles move independently, allowing for asymmetric curves.
    Displayed as black handles.

### NURBS

NURBS (Non-Uniform Rational B-Splines) are mathematically precise splines, offering exact shapes.
Unlike Bézier curves, which approximate shapes (e.g., a Bézier circle approximates a perfect circle),
NURBS can represent exact geometry.

For more information, refer to the [Wikipedia page](https://en.wikipedia.org/wiki/NURBS).
user: What is Built-In Attributes and how is it used in Blender Python scripting?

assistant: Built-in attributes always exist, and cannot be removed. Their data type and domain cannot be changed.

| Name | Type | Domain | Notes |
| --- | --- | --- | --- |
| `position` | *Vector* | *Point* | Built-in attribute describing vertex or point locations, in the local space of a geometry. Any node that changes the location of points will adjust this attribute, like the [Transform Geometry Node](geometry/operations/transform_geometry.xhtml) and the [Set Position Node](geometry/write/set_position.xhtml). |
| `radius` | *Float* | *Point* | A built-in attribute on point clouds used to set the size for the points in the viewport. Also built-in on curves, where it controls the size of each curve control point when converted to a mesh, or for other operations. |
| `id` | *Integer* | *Point* | Created by the [Distribute Points on Faces](point/distribute_points_on_faces.xhtml) to provide stability when the shape of the input mesh changes, and used on instances to create motion blur. Values are expected to be large, with no order. This attribute is used by nodes that generate randomness, like the [Random Value Node](utilities/random_value.xhtml). Unlike other built-in attributes, this attribute is not required, and can be removed. |
| `material_index` | *Integer* | *Face* | Used to specify the material slot for every face in a mesh. |
| `sharp_edge` | *Boolean* | *Edge* | Attribute determining if an edge should have flat (rather than smooth) shading enabled in the viewport or a render. |
| `sharp_face` | *Boolean* | *Face* | Attribute determining if a face should have flat (rather than smooth) shading enabled in the viewport or a render. |
| `resolution` | *Integer* | *Spline* | Determines the number of evaluated points between two control points of a spline. Only NURBS and Bézier splines have this attribute, for poly splines, the value is always one. |
| `cyclic` | *Boolean* | *Spline* | Determines whether the spline has a segment that connects its first and last control points. |
| `handle_left` | *Vector* | *Point* | Describes the location of the left handle of a curve control point, on the side of the curve’s start. Only exists when the curve contains a Bézier spline. |
| `handle_right` | *Vector* | *Point* | Describes the location of the right handle of a curve control point, on the side of the curve’s end. Only exists when the curve contains a Bézier spline. |
user: Give a detailed overview of Filter: syntax, arguments, return values, common patterns.

assistant: # Filter

These options control which types of data are included in the final render for the current view layer.

Include
:   Environment Cycles, EEVEE
    :   Disables rendering the *Environment* render pass in the final render.

    Surfaces Cycles, EEVEE
    :   Disables rendering object materials in the final render.

    Curves Cycles, EEVEE
    :   Disables rendering curve strands in the final render.

    Volume Cycles, EEVEE
    :   Disables rendering [Volumes](../../modeling/volumes/index.html) in the final render.

    Grease Pencil Cycles, EEVEE
    :   Render Grease Pencil objects on current layer

Use
:   Motion Blur Cycles, EEVEE
    :   Render motion blur for current layer,
        if enabled in the [Render Settings](../cycles/render_settings/motion_blur.html#bpy-types-rendersettings-use-motion-blur).
user: Show practical ways to work with Playback Controls in a Blender add-on or script – include code.

assistant: The Playback Controls region contains controls and options
related to playback, keying, auto keyframing, and transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.

Sync Scene Time
:   Set the active scene and time based on the current scene strip.
    See the [workspace settings](../../../interface/window_system/workspaces.xhtml#bpy-types-workspace-use-scene-time-sync).
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Grid
:   The input grid whose background value will be modified.

Background
:   The value to assign to inactive or uninitialized voxels and tiles.

    When sampling outside the defined region of the grid, this value will be
    returned instead of zero.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_modifiers_deform_smooth_mesh-before.png   Mesh before smoothing. | ../../../_images/modeling_modifiers_deform_smooth_mesh-one-iteration.png   Mesh after one smoothing iteration. | ../../../_images/modeling_modifiers_deform_smooth_mesh-ten-iterations.png   Mesh after ten smoothing iterations. |