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

assistant: # GeometryNodeMergeByDistance(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.GeometryNodeMergeByDistance(*GeometryNode*)
:   Merge vertices or points within a given distance

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

assistant: # Introduction

The Sequencer view is where most of the video editing happens.
It shows a stack of [channels](channels.xhtml),
in which you can create [strips](../../../video_editing/edit/montage/strips/introduction.xhtml).
user: Provide the full official documentation entry for OperatorOptions(bpy_struct), preserving all code examples.

assistant: # OperatorOptions(bpy_struct)

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

*class* bpy.types.OperatorOptions(*bpy_struct*)
:   Runtime options

    is_grab_cursor
    :   True when the cursor is grabbed

        Type:
        :   boolean, default False, (readonly)

    is_invoke
    :   True when invoked (even if only the execute callbacks available)

        Type:
        :   boolean, default False, (readonly)

    is_repeat
    :   True when run from the ‘Adjust Last Operation’ panel

        Type:
        :   boolean, default False, (readonly)

    is_repeat_last
    :   True when run from the operator ‘Repeat Last’

        Type:
        :   boolean, default False, (readonly)

    use_cursor_region
    :   Enable to use the region under the cursor for modal execution

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

assistant: These filters are available in the funnel dropdown button in the header.

Summary
:   Toggles the “Summary” row at the top of the Channels region.
    This row shows the union of all keyframes across all channels.

Only Show Selected
:   Only show keyframes belonging to objects/bones/… that are selected.

Show Hidden
:   Show keyframes from objects/bones/… that are hidden.

Only Show Errors
:   Only show channels that have errors (for example, because they try to animate a property that doesn’t
    exist on the object).

Search
:   Filters the channel list by a search term (or multiple search terms if *Multi-Word Match Search*
    is enabled).

Filtering Collection
:   Select a collection to only show keyframes from objects in that collection.

Filter by Type
:   Filter curves by property type.

Sort Data-Blocks
:   Sorts data-blocks alphabetically to make them easier to find.

    If your playback speed suffers because of this
    (should only really be an issue when working with lots of objects),
    you can turn it off.
user: Explain Auto-Masking in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Auto-Masking settings.

These properties automatically mask geometry based on stroke, layers and materials under the cursor.
It’s an quick alternative to frequent manual masking.
These masks are initialized on every new tool usage. They are also never visible as an overlay.

These properties can be accessed via a [Pie Menus](../../../interface/controls/buttons/menus.html#bpy-types-uipiemenu) by pressing `Shift`-`Alt`-`A`.

All auto-masking modes can be combined, which makes the generated auto-mask more specific.
For example it’s possible to auto-mask strokes that use specific layer and material while excluding others.

Stroke
:   Only strokes that are under the cursor when you started the tool are affected.

Layer
:   Only strokes on the same layers that are under the cursor when you started the tool are affected.

Material
:   Only materials with the same material that are under the cursor when you started the tool are affected.

Active Layer
:   Only the strokes on the active layer are affected.

Active Material
:   Only the strokes with the active material are affected.
user: How do I use NodeClosureInputItems(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeClosureInputItems(bpy_struct)

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

*class* bpy.types.NodeClosureInputItems(*bpy_struct*)
:   new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

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

    clear()
    :   Remove all items

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Scrolling

A region can be scrolled vertically and/or horizontally by dragging it with the `MMB`.
If the region has no zoom level, it can also be scrolled by using the `Wheel`
while the mouse hovers over it.

Some regions, in particular animation timelines, have scrollbars with added control points
to adjust the vertical or horizontal range of the region.
These special scrollbars will have added widgets at the ends, as shown in the following image:

[image reference removed]

Scrollbars with zoom widgets.

This can be used to stretch or compress the range to show more or less detail within the available screen space.
Simply drag one of the dots to either increase or decrease the displayed range.
You can also quickly adjust both the horizontal and vertical range by dragging in the editor with `Ctrl`-`MMB`.

### Changing the Size and Hiding Regions

Resizing regions works by dragging their border, the same way as
[Areas](areas.xhtml).

To hide a region, resize it down to nothing.
A hidden region leaves a little arrow sign.
`LMB` on this icon to make the region reappear.

Hiding and showing the Sidebar.

|  |  |
| --- | --- |
| ../../_images/interface_window-system_regions_sidebar-hide.png | ../../_images/interface_window-system_regions_sidebar-show.png |

### Scaling

The scale of certain regions (such as the Toolbar) can be changed by dragging inside them
with `Ctrl`-`MMB`, or using `NumpadPlus` and `NumpadMinus` while hovering the
mouse cursor over them. Press `Home` to reset the scale to the default.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Array modifier.

Count
:   Total number of copies.

Material Override
:   Index of the material to use on duplicated strokes (0 use strokes original materials).

### Relative Offset

Factor X, Y, Z
:   Adds a translation equal to the object’s bounding box size along each axis,
    multiplied by a scaling factor, to the offset. X, Y and Z scaling factors can be specified.

### Constant Offset

Factor X, Y, Z
:   Adds a constant translation component to the duplicate object’s offset.
    X, Y and Z constant components can be specified.

### Object Offset

Distance X, Y, Z
:   Adds a transformation taken from an object (relative to the current object) to the offset.
    It is good practice to use an empty object centered or near to the initial object.

### Randomize

Offset X, Y, Z
:   Add random offset values to the copies.

Rotation X, Y, Z
:   Add random rotation values to the copies.

Scale X, Y, Z
:   Add random scale values to the copies.

Uniform Scale
:   Use the same random *Seed* for each scale axis in the copies for a uniform scale.

Seed
:   [Seed](../../../glossary/index.html#term-Seed) used by the pseudo-random number generator.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.meta_ball`](bpy.context.html#bpy.context.meta_ball "bpy.context.meta_ball") - [`BlendData.metaballs`](bpy.types.BlendData.html#bpy.types.BlendData.metaballs "bpy.types.BlendData.metaballs") | - [`BlendDataMetaBalls.new`](bpy.types.BlendDataMetaBalls.html#bpy.types.BlendDataMetaBalls.new "bpy.types.BlendDataMetaBalls.new") - [`BlendDataMetaBalls.remove`](bpy.types.BlendDataMetaBalls.html#bpy.types.BlendDataMetaBalls.remove "bpy.types.BlendDataMetaBalls.remove") |
user: Explain BlendFileColorspace(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BlendFileColorspace(bpy_struct)

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

*class* bpy.types.BlendFileColorspace(*bpy_struct*)
:   Information about the color space used for data-blocks in a blend file

    is_missing_opencolorio_config
    :   A color space, view or display was not found, which likely means the OpenColorIO config used to create this blend file is missing

        Type:
        :   boolean, default False, (readonly)

    working_space
    :   Color space used for all scene linear colors in this file, and for compositing, shader and geometry nodes processing

        - `Linear Rec.709`
          Linear Rec.709 – Linear BT.709 with illuminant D65 white point.
        - `Linear Rec.2020`
          Linear Rec.2020 – Linear BT.2020 with illuminant D65 white point.
        - `ACEScg`
          ACEScg – Linear AP1 with ACES white point.

        Type:
        :   enum in [`'Linear Rec.709'`, `'Linear Rec.2020'`, `'ACEScg'`], (readonly)

    working_space_interop_id
    :   Unique identifier for common color spaces, as defined by the Color Interop Forum. May be empty if there is no interop ID for the working space. Common values are lin_rec709_scene, lin_rec2020_scene and lin_ap1_scene (for ACEScg)

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

assistant: The *Influence* is a strength multiplier for the constraint.

[image reference removed]

By default, it’s 1, meaning that (for example) a *Copy Location* constraint fully overrides
the object’s original location.

Setting it to 0 is the same as disabling or even deleting the constraint.

Setting it between 0 and 1 will give an interpolated result. For example, a value of 0.5 would
place the object halfway between its previous location and the location of the *Target*.

The *Influence* can be keyframed, meaning constraints can be turned on and off over the course
of an animation.

Disable and Keep Transform
:   [Applies](header.xhtml#bpy-ops-constraint-apply) the result of the constraint to the object’s/bone’s
    own transformation, but instead of deleting the constraint, disables it by setting the *Influence* to 0.
    As with applying, this may not work perfectly if the constraint is not the first in the stack.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

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

Scale
:   Overall texture scale.

Distortion
:   Amount of distortion of the wave.

Detail
:   Amount of distortion noise detail.

Detail Scale
:   Scale of distortion noise.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Phase Offset
:   Position of the wave along the *Bands Direction*.
    This can be used as an input for more control over the distortion.
user: Show practical ways to work with Keying Flag Api Items in a Blender add-on or script – include code.

assistant: # Keying Flag Api Items

INSERTKEY_NEEDED:
:   Only Needed.

    Only insert keyframes where they’re needed in the relevant F-Curves.

INSERTKEY_VISUAL:
:   Visual Keying.

    Insert keyframes based on ‘visual transforms’.

INSERTKEY_REPLACE:
:   Replace Existing.

    Only replace existing keyframes.

INSERTKEY_AVAILABLE:
:   Only Available.

    Don’t create F-Curves when they don’t already exist.

INSERTKEY_CYCLE_AWARE:
:   Cycle Aware Keying.

    When inserting into a curve with cyclic extrapolation, remap the keyframe inside the cycle time range, and if changing an end key, also update the other one.
user: How do I use In Edit Mode in Blender? Include parameters, examples, warnings and best practices.

assistant: When in Edit Mode, rotation and scaling happen around the centerpoint of
the active element, which is the element with a white outline.
That centerpoint remains in the same location while everything else
is transformed around it.

The image below illustrates rotation around the active vertex,
edge, and face. Each time, the active element rotates in place,
while the others “orbit” around it. In the case of vertices,
the active vertex is not changed at all, as a vertex on its own
is just a point that has no concept of rotation.

[image reference removed]

Left column: starting situation, right column: after rotation.
user: Show practical ways to work with Set Spline Type in a Blender add-on or script – include code.

assistant: Converts splines in a curve object between Bézier, NURBS, Poly, and Catmull Rom types.
This is a basic conversion, meaning Blender does not preserve the exact shape or the number of control points.
For example, converting a NURBS spline to a Bézier spline maps each group of three NURBS control points
to a single Bézier control point with two handles.

Type
:   Specifies the target spline type. For more details on spline types, see the
    [Spline Types](../structure.xhtml#curve-spline-types) documentation.

    Bézier:
    :   Converts the spline to a Bézier type.
        - Poly splines are converted with vector handles.
        - NURBS or Catmull Rom splines are converted with automatic handles.

    NURBS:
    :   Converts the spline to a NURBS type.

    Poly:
    :   Converts the spline to a poly type.

Handles
:   Includes handle information during the conversion process.
user: Describe RenderPasses(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # RenderPasses(bpy_struct)

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

*class* bpy.types.RenderPasses(*bpy_struct*)
:   Collection of render passes

    find_by_name(*name*, *view*)
    :   Get the render pass for a given name and view

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Pass
            - **view** (*string**,* *(**never None**)*) – View, Render view to get pass from

        Returns:
        :   The matching render pass

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

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

assistant: |  |  |
| --- | --- |
| - [**Saturation**](glossary/index.xhtml#term-Saturation) - [**Scanline**](glossary/index.xhtml#term-Scanline) - [**Scene Referenced**](glossary/index.xhtml#term-Scene-Referenced) - [**Seed**](glossary/index.xhtml#term-Seed) - [**Session**](glossary/index.xhtml#term-Session) - Shader Nodes   - [Color Ramp](render/shader_nodes/color/color_ramp.xhtml#index-0)   - [Combine XYZ](render/shader_nodes/utilities/vector/combine_xyz.xhtml#index-0)   - [Math](render/shader_nodes/utilities/math/math.xhtml#index-0)   - [Menu Switch](render/shader_nodes/utilities/menu_switch.xhtml#index-0)   - [Mix Vector](render/shader_nodes/utilities/vector/mix_vector.xhtml#index-0)   - [Separate XYZ](render/shader_nodes/utilities/vector/separate_xyz.xhtml#index-0) | - [**Shading**](glossary/index.xhtml#term-Shading) - [**Smoothing**](glossary/index.xhtml#term-Smoothing) - [**Specular Light**](glossary/index.xhtml#term-Specular-Light) - [**SSS**](glossary/index.xhtml#term-SSS) - [**Straight Alpha**](glossary/index.xhtml#term-Straight-Alpha) - [**Subdiv**](glossary/index.xhtml#term-Subdiv) - [**Subdividing**](glossary/index.xhtml#term-Subdividing) - [**Subdivision Surface**](glossary/index.xhtml#term-Subdivision-Surface) - [**Subsurface Scattering**](glossary/index.xhtml#term-Subsurface-Scattering) - [**Swing**](glossary/index.xhtml#term-Swing) - [**Swing and Twist**](glossary/index.xhtml#term-Swing-and-Twist) |
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Minimum
:   Determines the lowest values that are considered foreground.
    (Which is supposed to be – relatively – high values: from this value to 1.0.)

Maximum
:   Determines the highest values that are considered to be background objects.
    (Which is supposed to be – relatively – low values: from 0.0 to this value.)

Color Space
:   This button selects what color model the channels will represent.

    RGB, HSV, YUV, YCbCr

Key Channel
:   This button selects the channel, defined by the *Color Space*, to use to determine the matte.

Limit Method
:   Method to calculate the difference between levels.

    Max:
    :   Limit by the maximum of the other two channels other than the *Key Channel*.

    Single:
    :   Limit by the maximum of the selected *Limit Channel*.

Limit Channel
:   The channel to use when computing the maximum, the options are defined by the *Color Space*.
user: What is In Object Mode and how is it used in Blender Python scripting?

assistant: Each object gets transformed around its [origin](../../../../scene_layout/object/origin.xhtml),
which is a point that can be chosen freely and doesn’t have to be in the center.
In the example below, the orange rectangle has it in a corner instead.

[image reference removed]

Rotation around individual origins.

The images below compare Individual Origins to [Median Point](median_point.xhtml).

[image reference removed]

Starting situation, rotation around Individual Origins, rotation around Median Point.

[image reference removed]

Starting situation, scaling using Individual Origins, scaling using Median Point.
user: What is Custom Camera and how is it used in Blender Python scripting?

assistant: # Custom Camera

In addition to the built-in camera types (Perspective, Orthographic and Panoramic cameras),
Cycles also supports implementing custom cameras using
[Open Shading Language](https://github.com/AcademySoftwareFoundation/OpenShadingLanguage) (OSL).

Custom cameras are implemented as OSL shaders. A camera shader receives a sensor position
as its input and outputs the corresponding ray’s position, direction and throughput.

OSL for shading and custom cameras are independent, so the latter can be used even when OSL shading
is disabled.
user: What is Dt Mix Mode Items and how is it used in Blender Python scripting?

assistant: # Dt Mix Mode Items

REPLACE:
:   Replace.

    Overwrite all elements’ data.

ABOVE_THRESHOLD:
:   Above Threshold.

    Only replace destination elements where data is above given threshold (exact behavior depends on data type).

BELOW_THRESHOLD:
:   Below Threshold.

    Only replace destination elements where data is below given threshold (exact behavior depends on data type).

MIX:
:   Mix.

    Mix source value into destination one, using given threshold as factor.

ADD:
:   Add.

    Add source value to destination one, using given threshold as factor.

SUB:
:   Subtract.

    Subtract source value to destination one, using given threshold as factor.

MUL:
:   Multiply.

    Multiply source value to destination one, using given threshold as factor.
user: Show practical ways to work with Denoising in a Blender add-on or script – include code.

assistant: Denoising uses a specialized algorithm to get a less noisy image without requiring more samples.

Denoise (Viewport)
:   Whether to perform denoising for the 3D Viewport in the *Rendered* shading mode.

Denoise (Render)
:   Whether to perform denoising for the final rendered image.

Denoiser
:   The algorithm to use.

    Automatic:
    :   Uses GPU accelerated denoising if supported, for best performance.
        Prefers OpenImageDenoise over OptiX.

    OpenImageDenoise:
    :   Uses Intel’s [Open Image Denoise](https://www.openimagedenoise.org/),
        an AI denoiser. Typically provides the highest quality.

    OptiX:
    :   Uses NVIDIA’s OptiX AI denoiser.
        Supports GPU acceleration on some older NVIDIA GPUs where OpenImageDenoise does not.

        Only available on NVIDIA GPUs when configured in the [Cycles Render Devices](../../../editors/preferences/system.xhtml#editors-preferences-cycles) user preferences.

Passes
:   Controls which [Render Passes](../../layers/passes.xhtml) the denoiser should use as input.
    Generally, the more passes the denoiser has access to, the better the result.
    It is recommended to use at least *Albedo* as *None* can blur out details,
    especially at lower sample counts.

    None:
    :   Denoises the image using color data.

    Albedo:
    :   Denoises the image using color and albedo data.

    Albedo + Normal:
    :   Denoises the image using color, albedo, and normal pass data.

Prefilter OpenImageDenoise
:   Controls whether prefiltering is applied to the *Passes* before denoising.
    Visible only when using *OpenImageDenoise*.

    None:
    :   Does not apply any prefiltering to the input passes. This option retains the most detail and
        is the fastest, but assumes the input passes are noise free which may require a high sample count.
        If the input passes aren’t noise free, then noise will remain in the image after denoising.

    Fast:
    :   Assumes the input passes are not noise free, yet does not apply prefiltering to the input passes.
        This option is faster than *Accurate* but produces a blurrier result.

    Accurate:
    :   Prefilters the input passes before denoising to reduce noise. This option usually produces
        more detailed results than *Fast*, but with increased processing time.

Quality OpenImageDenoise
:   Overall denoising quality.
    Visible only when using *OpenImageDenoise*.

    High:
    :   Produces the highest quality at the cost of time.

    Balanced:
    :   Balanced between performance and quality.

    Fast:
    :   Sacrifices quality for speed (ideal for viewport rendering).

Start Sample
:   Sample at which to start denoising in the 3D Viewport.

Use GPU
:   Perform denoising on the GPU.
    This is significantly faster than on CPU, but requires additional GPU memory.
    When large scenes need more GPU memory, this option can be disabled.

    See [GPU Rendering](../gpu_rendering.xhtml) for details on supported GPUs.
user: How do I use Channel Key Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Channel Key Node

[image reference removed]

The *Channel Key* node determines background objects from foreground objects by
the difference in the selected channel’s levels.

For example in the YUV [Color Model](../../../glossary/index.html#term-Color-Model),
this node is useful when compositing stock footage of explosions (very bright)
which are normally shot against a solid, dark background.
user: Show practical ways to work with Clean Up in a Blender add-on or script – include code.

assistant: ### Decimate Curve

The *Decimate Curve* operator reduces the number of control points
while trying to maintain the curves original shape.
This operator works similar to its [mesh counterpart](../../meshes/editing/mesh/cleanup.xhtml#bpy-ops-mesh-decimate).

Ratio
:   The percentage of control points to remove.
user: Show practical ways to work with FollowTrackConstraint(Constraint) in a Blender add-on or script – include code.

assistant: # FollowTrackConstraint(Constraint)

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

*class* bpy.types.FollowTrackConstraint(*Constraint*)
:   Lock motion to the target motion track

    camera
    :   Camera to which motion is parented (if empty active scene camera is used)

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

    clip
    :   Movie Clip to get tracking data from

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

    depth_object
    :   Object used to define depth in camera space by projecting onto surface of this object

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

    frame_method
    :   How the footage fits in the camera frame

        Type:
        :   enum in [`'STRETCH'`, `'FIT'`, `'CROP'`], default `'STRETCH'`

    object
    :   Movie tracking object to follow (if empty, camera object is used)

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

    track
    :   Movie tracking track to follow

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

    use_3d_position
    :   Use 3D position of track to parent to

        Type:
        :   boolean, default False

    use_active_clip
    :   Use active clip defined in scene

        Type:
        :   boolean, default False

    use_undistorted_position
    :   Parent to undistorted position of 2D track

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

assistant: The mesh editing operations are found in various places, and available through shortcuts as well.

### Menus

These menus are located in the header.
Some of the menus can be accessed with shortcuts:

- `Ctrl`-`F` brings up the Face operators menu
- `Ctrl`-`E` brings up the Edge operators menu
- `Ctrl`-`V` brings up the Vertex operators menu
user: Provide the full official documentation entry for Adding Properties to a Keying Set, preserving all code examples.

assistant: Some ways to add properties to Keying Sets.

`RMB` the property in the *User Interface*, then select *Add Single to Keying Set* or *Add All to Keying Set*.
This will add the properties to the active Keying Set, or to a new Keying Set if none exist.

Hover the mouse over the properties, then press `K`, to add *Add All to Keying Set*.
user: Give a detailed overview of Snapping: syntax, arguments, return values, common patterns.

assistant: Transform operations use the [snapping settings](../../editors/3dview/controls/snapping.xhtml) set in the scene.
However, some options can be changed during the transformation.

### Snap Invert

Even if the magnetic icon is disabled, you can still enable snapping during a transformation.
The default hotkey in this case is `Ctrl`.

### Set Snap Base

The Snap Base is automatically determined based on the [Snap Base](../../editors/3dview/controls/snapping.xhtml#bpy-types-toolsettings-snap-target) options.
However, this automatic snap detection point of origin may not always align with the user’s intentions.
Therefore, transform operations include a utility to set a new snap origin point during the transformation.
The new Snap Base will correspond to the snap point whose target is defined by the
[Snap Target](../../editors/3dview/controls/snapping.xhtml#bpy-types-toolsettings-snap-elements-base).

By default the hotkey is `B`.

### Add Snap Point

While you’re transforming a selection with snapping enabled,
you can press `A` whenever there’s a highlighted snap target to
mark it. With multiple such targets marked, the selection will
then be snapped to their average location.

Marking a target more than once will give it more weight.

[image reference removed]

Multiple snapping targets.
user: Give a detailed overview of Advanced: syntax, arguments, return values, common patterns.

assistant: ### The Offset/Power/Slope Formula

\(\text{out} = (i \times s + o)^p\)

where:

- *out*: The color graded pixel code value.
- *i*: The input pixel code value (0 to 1) (black to white).
- *s*: Slope (any number 0 or greater, nominal value is 1.0).
- *o*: Offset (any number, the nominal value is 0).
- *p*: Power (any number greater than 0, nominal value is 1.0).
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Paint.brush`](bpy.types.Paint.html#bpy.types.Paint.brush "bpy.types.Paint.brush") - [`Paint.brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.brush_asset_reference "bpy.types.Paint.brush_asset_reference") - [`Paint.eraser_brush`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush "bpy.types.Paint.eraser_brush") - [`Paint.eraser_brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush_asset_reference "bpy.types.Paint.eraser_brush_asset_reference") - [`Paint.palette`](bpy.types.Paint.html#bpy.types.Paint.palette "bpy.types.Paint.palette") - [`Paint.show_brush`](bpy.types.Paint.html#bpy.types.Paint.show_brush "bpy.types.Paint.show_brush") - [`Paint.show_brush_on_surface`](bpy.types.Paint.html#bpy.types.Paint.show_brush_on_surface "bpy.types.Paint.show_brush_on_surface") - [`Paint.show_low_resolution`](bpy.types.Paint.html#bpy.types.Paint.show_low_resolution "bpy.types.Paint.show_low_resolution") - [`Paint.use_sculpt_delay_updates`](bpy.types.Paint.html#bpy.types.Paint.use_sculpt_delay_updates "bpy.types.Paint.use_sculpt_delay_updates") - [`Paint.use_symmetry_x`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_x "bpy.types.Paint.use_symmetry_x") - [`Paint.use_symmetry_y`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_y "bpy.types.Paint.use_symmetry_y") | - [`Paint.use_symmetry_z`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_z "bpy.types.Paint.use_symmetry_z") - [`Paint.use_symmetry_feather`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_feather "bpy.types.Paint.use_symmetry_feather") - [`Paint.cavity_curve`](bpy.types.Paint.html#bpy.types.Paint.cavity_curve "bpy.types.Paint.cavity_curve") - [`Paint.use_cavity`](bpy.types.Paint.html#bpy.types.Paint.use_cavity "bpy.types.Paint.use_cavity") - [`Paint.tile_offset`](bpy.types.Paint.html#bpy.types.Paint.tile_offset "bpy.types.Paint.tile_offset") - [`Paint.tile_x`](bpy.types.Paint.html#bpy.types.Paint.tile_x "bpy.types.Paint.tile_x") - [`Paint.tile_y`](bpy.types.Paint.html#bpy.types.Paint.tile_y "bpy.types.Paint.tile_y") - [`Paint.tile_z`](bpy.types.Paint.html#bpy.types.Paint.tile_z "bpy.types.Paint.tile_z") - [`Paint.show_strength_curve`](bpy.types.Paint.html#bpy.types.Paint.show_strength_curve "bpy.types.Paint.show_strength_curve") - [`Paint.show_size_curve`](bpy.types.Paint.html#bpy.types.Paint.show_size_curve "bpy.types.Paint.show_size_curve") - [`Paint.show_jitter_curve`](bpy.types.Paint.html#bpy.types.Paint.show_jitter_curve "bpy.types.Paint.show_jitter_curve") - [`Paint.unified_paint_settings`](bpy.types.Paint.html#bpy.types.Paint.unified_paint_settings "bpy.types.Paint.unified_paint_settings") |
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeIndexSwitch.index_switch_items`](bpy.types.GeometryNodeIndexSwitch.html#bpy.types.GeometryNodeIndexSwitch.index_switch_items "bpy.types.GeometryNodeIndexSwitch.index_switch_items") |  |
user: Give a detailed overview of Dt Method Vertex Items: syntax, arguments, return values, common patterns.

assistant: # Dt Method Vertex Items

TOPOLOGY:
:   Topology.

    Copy from identical topology meshes.

NEAREST:
:   Nearest Vertex.

    Copy from closest vertex.

EDGE_NEAREST:
:   Nearest Edge Vertex.

    Copy from closest vertex of closest edge.

EDGEINTERP_NEAREST:
:   Nearest Edge Interpolated.

    Copy from interpolated values of vertices from closest point on closest edge.

POLY_NEAREST:
:   Nearest Face Vertex.

    Copy from closest vertex of closest face.

POLYINTERP_NEAREST:
:   Nearest Face Interpolated.

    Copy from interpolated values of vertices from closest point on closest face.

POLYINTERP_VNORPROJ:
:   Projected Face Interpolated.

    Copy from interpolated values of vertices from point on closest face hit by normal-projection.
user: Describe Split Non-Planar Faces from the Blender manual or Python API, including usage steps and snippets.

assistant: Splits any selected faces that are bent beyond a given limit.

Max Angle
:   Faces that are bent by more than this angle will be split.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-non-planar-before.png   Original mesh. | ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-non-planar-after.png   Result of Split Non-Planar Faces. |
user: Provide the full official documentation entry for [Draw Brushes](draw.html), preserving all code examples.

assistant: Draw brushes are the special type of brushes that uses Grease Pencil for drawing tools.
The brush can be changed in the Tool Settings.
The different draw brushes (pencil, Ink, marker, etc.) are settings variations of the same *Draw Brush*.
You can create many brushes, each with unique settings to get different artistic result while drawing.
user: What is Examples and how is it used in Blender Python scripting?

assistant: ### Creating an Alpha Mask

An often overlooked use case of the Color Ramp is to turn a black-and-white image
into a colored image with transparency.

[image reference removed]

In the example above, a black-and-white swirl image, which is lacking an alpha channel,
is fed into the Color Ramp node as a *Factor*.

The Color Ramp node is set to a purely transparent color on the left end of the gradient,
and a fully red color on the right. As you can see in the Viewer node,
the Color Ramp node outputs an image that is transparent where the input is black,
and opaque where the input is white.

### Colorizing an Image

In this example, multiple colors are added to the color gradient,
converting a black-and-white image into a flaming swirl.

[image reference removed]

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.
user: Give a detailed overview of Filtering: syntax, arguments, return values, common patterns.

assistant: Below the preset list, you can filter the list of operations so you can quickly find the one you need.

Filter Type
:   Name:
    :   Filter the operations by their name (such as `New File`).

    Key Binding:
    :   Filter the operations by their currently assigned shortcut (such as `ctrl n`).

Search
:   The text to search (leave blank to show all operations).
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Preferences.studio_lights`](bpy.types.Preferences.html#bpy.types.Preferences.studio_lights "bpy.types.Preferences.studio_lights") - [`StudioLights.load`](bpy.types.StudioLights.html#bpy.types.StudioLights.load "bpy.types.StudioLights.load") - [`StudioLights.new`](bpy.types.StudioLights.html#bpy.types.StudioLights.new "bpy.types.StudioLights.new") | - [`StudioLights.remove`](bpy.types.StudioLights.html#bpy.types.StudioLights.remove "bpy.types.StudioLights.remove") - [`View3DShading.selected_studio_light`](bpy.types.View3DShading.html#bpy.types.View3DShading.selected_studio_light "bpy.types.View3DShading.selected_studio_light") |
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image
:   Standard color input.

Type
:   Radial:
    :   Radially distorts the image to create a barrel or a Pincushion distortion.

    Horizontal:
    :   Horizontally distorts the image to create a channel/color shifting effect.

Distortion Radial
:   This creates a bulging or pinching effect from the center of the image.

Dispersion
:   This simulates chromatic aberrations, where different wavelengths of light refract slightly differently,
    creating a rainbow colored fringe.

Jitter
:   Adds jitter to the distortion. Faster, but noisier.

Fit Radial
:   Scales image so black areas are not visible. Only works for positive distortion.
user: Show practical ways to work with Viewport Overlays in a Blender add-on or script – include code.

assistant: # Viewport Overlays

Clicking  (Show Overlays) toggles all overlays in the 3D Viewport.

The drop-down button displays a popover with more detailed settings, which are described below.

Depending on the current [object interaction mode](../modes.html),
there may be a second button with yet more settings, which are also described here.
user: How do I use Particle Info Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Particle Info Node

Cycles Only

[image reference removed]

The *Particle Info* node can be used in the material node tree for objects that are used as the instancing objects,
when you use *Object* or *Collection* [Render mode](../../../physics/particles/emitter/render.xhtml) of a particle system.

This node gives access to the data of the particle that spawned the object instance.
It can be useful to give some variation to a single material assigned to multiple instances of instancing object.
user: Explain Luminance Key Node in complete detail according to the official Blender documentation.

assistant: # Luminance Key Node

[image reference removed]

The *Luminance Key* node determines background objects from foreground objects by
the difference in the luminance (brightness) levels.

Stock footage of explosions, smoke or debris are normally shot against a solid,
dark background rather than a green screen.
This node can separate the foreground effect from the background.
It can also be used for sky replacement for overexposed or gray skies
that aren’t suitable for chroma keying.
user: Explain Performance in complete detail according to the official Blender documentation.

assistant: ### Slow Rendering

There are a couple of reasons why you may be experiencing a slow viewport.

Old Hardware
:   Sometimes your hardware, mainly your graphics card, may be too slow to keep up with your model.

Upgrade Graphics Driver
:   In some cases, slow selection is resolved by using updated drivers.

### Slow Selection

Blender uses OpenGL for selection, some graphics card drivers are slow at performing this operation.

This becomes especially problematic on dense geometry.

Possible Solutions:

GPU Depth Picking (Preferences)
:   See Preferences ‣ Viewport ‣ Selection.

    This option is enabled by default, disabling it may give a better performance at the cost of selection accuracy.

Upgrade Graphics Driver
:   In some cases, slow selection is resolved by using updated drivers. *It is generally good to use recent drivers
    when using 3D software.*

Select Centers (Workaround)
:   In *Object Mode*, holding `Ctrl` while selecting uses the object center point. While this can be useful on its
    own, it has the side effect of not relying on OpenGL selection.

Change Display Mode (Workaround)
:   Using *Wireframe* display mode can be used to more quickly select different objects.

### Viewport Playback Frame Rate Limited

Having the viewport playback clamped to a maximum of 60 FPS is typically caused by the VSync (vertical sync) setting
on your GPU, for higher frame rates you may have to disable VSync functionality although this may be of limited us
since frames rendered may be more than your GPU and monitor are able to display.

VSync is configured as part of your GPU driver options which vary depending on your system & GPU combination.
user: How do I use Compatibility in Blender? Include parameters, examples, warnings and best practices.

assistant: In some cases, Blender may crash on startup. Running Blender in compatibility mode can help in fixing this issue. To
enable compatibility mode, `RMB` on the Blender executable and select Properties ‣
Compatibility and enable Run this program in compatibility mode. Confirm the changes with *Apply*.
user: What is In Object Mode and how is it used in Blender Python scripting?

assistant: In Object Mode, the Median Point is the averaged-out position of the
[origins](../../../../scene_layout/object/origin.xhtml) of the selected objects.
The shape and size of the objects is not taken into account.

Origins can be chosen freely and can even lie outside their object’s
geometry, so that the Median Point is not always what you might expect.

[image reference removed]

Median points in Object Mode.
user: Give a detailed overview of Camera & Lens Effects Nodes: syntax, arguments, return values, common patterns.

assistant: # Camera & Lens Effects Nodes

The *Camera & Lens Effects* nodes simulate real-world imperfections and optical
characteristics of cameras and lenses. These effects can be used to add realism,
match rendered imagery with live-action footage, or achieve specific cinematic looks.

These nodes are typically applied near the end of a compositing chain to stylize or enhance
the final image. They include effects such as sensor noise, chromatic aberration,
and vignetting, all of which help replicate the subtleties of physical camera systems.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_sheen_example.png   The Sheen shader example. | ../../../_images/render_shader-nodes_shader_sheen_behavior.svg   The Sheen shader behavior. |
user: Show practical ways to work with Brush Asset in a Blender add-on or script – include code.

assistant: # Brush Asset

[image reference removed]

Brush data-block panel.

Brush
:   The [Data-Block Menu](../../../../interface/controls/templates/data_block.xhtml#ui-data-block) to select a preset brush type or a custom brush.

    Add Brush
    :   When you add a brush, the new brush is a clone of the current one.

    Brush Specials
    :   Reset Brush
        :   Reset the current brush to its default settings.

        Reset All Brushes
        :   Reset all brushes to their default settings.

        Custom Icon
        :   Allows definition of a custom brush icon.

            Image Path
            :   Defines the path to the image to use as custom icon.