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

assistant: Vector
:   Vector specifying the displacement along three axes.
    This is where a texture node can be connected.

    Typically a baked vector displacement image texture is used.
    For Object Space, RGB colors in the image are interpreted as an XYZ offset in object space.
    For Tangent Space, R is an offset along the tangent, G along the normal and B along the bitangent.

Midlevel
:   Neutral displacement value that causes no displacement.
    With the default 0.0, any lower values will cause the surfaces to be pushed inwards,
    and any higher values will push them outwards.

Scale
:   Increase or decrease the amount of displacement.
user: Explain Mirror in complete detail according to the official Blender documentation.

assistant: Mirrors the selected keyframes across a reference point.

By Times over Current Frame
:   Mirror horizontally across the current frame.

By Values over Cursor Value
:   Mirror vertically across the 2D Cursor’s value.

By Times over Zero Time
:   Mirror horizontally across frame 0.

By Values over Zero Value
:   Mirror vertically across value 0.

By Times over First Selected Marker
:   Mirror horizontally across the first selected marker.
user: Provide the full official documentation entry for Snap, preserving all code examples.

assistant: Snapping in the UV Editor is similar to
[Snapping in 3D](../../../editors/3dview/controls/snapping.xhtml).
For the snap to pixel options to work an image has to be loaded.

Selected to Pixels
:   Moves selection to nearest pixel. See also *Round to Pixels* below.

Selected to Cursor
:   Moves selection to 2D cursor location.

Selected to Cursor (Offset)
:   Moves selection center to 2D cursor location, while preserving the offset of the vertices from the center.

Selected to Adjacent Unselected
:   Moves selection to adjacent unselected element.

Cursor to Pixels
:   Snaps the cursor to the nearest pixels.

Cursor to Selected
:   Moves the Cursor to the center of the selection.

Cursor to Origin
:   Places the cursor to the location (0, 0, 0).
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Seconds
:   Current scene time in seconds.

Frames
:   Current scene frame.
    As an input in geometry nodes, this output may also output non-round numbers,
    in order to support higher quality [motion blur](../../../../render/eevee/render_settings/motion_blur.xhtml).
user: Provide the full official documentation entry for OperatorStrokeElement(PropertyGroup), preserving all code examples.

assistant: # OperatorStrokeElement(PropertyGroup)

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

*class* bpy.types.OperatorStrokeElement(*PropertyGroup*)
:   is_start
    :   Type:
        :   boolean, default False

    location
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    mouse
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    mouse_event
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    pressure
    :   Tablet pressure

        Type:
        :   float in [0, 1], default 0.0

    size
    :   Brush size in screen space

        Type:
        :   float in [0, inf], default 0.0

    time
    :   Type:
        :   float in [0, inf], default 0.0

    x_tilt
    :   Pen tilt from left (-1.0) to right (+1.0)

        Type:
        :   float in [-1, 1], default 0.0

    y_tilt
    :   Pen tilt from backward (-1.0) to forward (+1.0)

        Type:
        :   float in [-1, 1], default 0.0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |  |
| --- | --- | --- |
| ../../../_images/physics_cloth_introduction_example1.jpg   Cloth example. | ../../../_images/physics_cloth_introduction_oncarved-wood.jpg   Cloth on carved wooden men (made by motorsep). | ../../../_images/physics_cloth_introduction_example2.jpg   Cloth example. |
user: What is Physics Menu and how is it used in Blender Python scripting?

assistant: Also you can create *Rigid Body Constraint* on one of the two constrained objects with
*Rigid Body Constraint* button of the *Physics* tab in the Properties.
This constraint is dependent on the object location and rotation on which it was created.
This way, there are no empty object created for the constraint.
The role of the empty object is put on this object.
The constrained object can be then be set as a *Passive* type for better driving of the constraint.

Additional parameters appear in the *Rigid Body Constraint* panel of the *Physics* tab in the Properties
for the selected empty object or the one of the two constrained objects with the created constraint.
user: Provide the full official documentation entry for Property Definitions (bpy.props), preserving all code examples.

assistant: # Property Definitions (bpy.props)

This module defines properties to extend Blender’s internal data. The result of these functions is used to assign properties to classes registered with Blender and can’t be used directly.
user: Give a detailed overview of TextureNodeTexVoronoi(TextureNode): syntax, arguments, return values, common patterns.

assistant: # TextureNodeTexVoronoi(TextureNode)

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

*class* bpy.types.TextureNodeTexVoronoi(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`PropertyGroup.name`](bpy.types.PropertyGroup.html#bpy.types.PropertyGroup.name "bpy.types.PropertyGroup.name") |
user: Provide the full official documentation entry for Viewer Node, preserving all code examples.

assistant: # Viewer Node

[image reference removed]

The *Viewer* node is used to preview image data or value maps anywhere within a compositor node graph.
It is a diagnostic tool that allows users to inspect intermediate results without affecting the final output.

You can quickly assign a node to a Viewer by pressing `Shift`-`Ctrl`-`LMB` on the desired node.
To switch between multiple Viewer nodes, simply select one with `LMB`.
Only the active Viewer node (with the  icon in the header)
will be displayed in the backdrop or Image Editor.
user: How do I use EnumProperty(Property) in Blender? Include parameters, examples, warnings and best practices.

assistant: # EnumProperty(Property)

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

*class* bpy.types.EnumProperty(*Property*)
:   RNA enumeration property definition, to choose from a number of predefined options

    default
    :   Default value for this enum

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`, (readonly)

    default_flag
    :   Default value for this enum

        Type:
        :   enum set in {`'DEFAULT'`}, default set(), (readonly)

    enum_items
    :   Possible values for the property

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`EnumPropertyItem`](bpy.types.EnumPropertyItem.html#bpy.types.EnumPropertyItem "bpy.types.EnumPropertyItem"), (readonly)

    enum_items_static
    :   Possible values for the property (never calls optional dynamic generation of those)

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`EnumPropertyItem`](bpy.types.EnumPropertyItem.html#bpy.types.EnumPropertyItem "bpy.types.EnumPropertyItem"), (readonly)

    enum_items_static_ui
    :   Possible values for the property (never calls optional dynamic generation of those). Includes UI elements (separators and section headings).

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`EnumPropertyItem`](bpy.types.EnumPropertyItem.html#bpy.types.EnumPropertyItem "bpy.types.EnumPropertyItem"), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Accumulate Field Node, preserving all code examples.

assistant: # Accumulate Field Node

[image reference removed]

The *Accumulate Field* node counts a running total of its input values, in the order defined
by the geometry’s [indices](../../geometry/read/input_index.xhtml). The node’s essential
operation is just addition, but instead of only outputting the final total, it outputs the current
value at every element.
user: How do I use Keyboard in Blender? Include parameters, examples, warnings and best practices.

assistant: Emulate Numpad
:   The Numpad keys are used quite often in Blender and are not assigned to the same action as
    the regular number keys. If you have a keyboard without a Numpad (e.g. on a laptop),
    you can tell Blender to treat the standard number keys as Numpad keys by checking *Emulate Numpad*.

Default to Advanced Numeric Input
:   For transform mode, default to [Advanced Mode](../../scene_layout/object/editing/transform/control/numeric_input.xhtml#transform-numeric-input-advanced),
    otherwise [Simple Mode](../../scene_layout/object/editing/transform/control/numeric_input.xhtml#transform-numeric-input-simple) is used.
user: Provide the full official documentation entry for Debug, preserving all code examples.

assistant: Undo Legacy
:   Use legacy undo (slower than the new default one, but may be more stable in some cases).

No Override Auto Resync
:   Disables library overrides automatic resync detection and process on file load.
    Enable when dealing with older blend-files that need manual Resync (Enforce) handling.

Cycles Debug
:   Show the Cycles rendering debug panel.

Asset Debug Info
:   Enable some extra fields in the Asset Browser to aid debugging.

Asset Indexing
:   Disabling the asset indexer forces every asset library refresh to completely reread assets from disk.

Viewport Debug
:   Enable viewport debugging options for developers in the overlays pop-over.

EEVEE Debug
:   Enable EEVEE debugging options for developers.
user: Provide the full official documentation entry for BlendImportContextLibrary(bpy_struct), preserving all code examples.

assistant: # BlendImportContextLibrary(bpy_struct)

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

*class* bpy.types.BlendImportContextLibrary(*bpy_struct*)
:   Library (blendfile) reference in a BlendImportContext data. Currently only exposed as read-only data for the pre/post blendimport handlers

    filepath
    :   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: Explain Freestyle Shaders (freestyle.shaders) in complete detail according to the official Blender documentation.

assistant: :   Limits the stroke’s alpha between a min and max value.

    shade(*stroke*)

*class* freestyle.shaders.pyNonLinearVaryingThicknessShader
:   Assigns thickness to a stroke based on an exponential function.

    shade(*stroke*)

*class* freestyle.shaders.pyPerlinNoise1DShader
:   Displaces the stroke using the curvilinear abscissa. This means
    that lines with the same length and sampling interval will be
    identically distorted.

    shade(*stroke*)

*class* freestyle.shaders.pyPerlinNoise2DShader
:   Displaces the stroke using the strokes coordinates. This means
    that in a scene no strokes will be distorted identically.

    More information on the noise shaders can be found at:
    <https://freestyleintegration.wordpress.com/2011/09/25/development-updates-on-september-25/>

    shade(*stroke*)

*class* freestyle.shaders.pyRandomColorShader
:   Assigns a color to the stroke based on given seed.

    shade(*stroke*)

*class* freestyle.shaders.pySLERPThicknessShader
:   Assigns thickness to a stroke based on spherical linear interpolation.

    shade(*stroke*)

*class* freestyle.shaders.pySamplingShader
:   Resamples the stroke, which gives the stroke the amount of
    vertices specified.

    shade(*stroke*)

*class* freestyle.shaders.pySinusDisplacementShader
:   Displaces the stroke in the shape of a sine wave.

    shade(*stroke*)

*class* freestyle.shaders.pyTVertexRemoverShader
:   Removes t-vertices from the stroke.

    shade(*stroke*)

*class* freestyle.shaders.pyTVertexThickenerShader
:   Thickens TVertices (visual intersections between two edges).

    shade(*stroke*)

*class* freestyle.shaders.pyTimeColorShader
:   Assigns a grayscale value that increases for every vertex.
    The brightness will increase along the stroke.

    shade(*stroke*)

*class* freestyle.shaders.pyTipRemoverShader
:   Removes the tips of the stroke.

    shade(*stroke*)

    Undocumented

*class* freestyle.shaders.pyZDependingThicknessShader
:   Assigns thickness based on an object’s local Z depth (point
    closest to camera is 1, point furthest from camera is zero).

    shade(*stroke*)
user: Describe Cloth Sculpting from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cloth Sculpting

Instead of sculpting cloth manually or creating complex physics simulation setups,
there are various tools directly in sculpt mode that offer a simplified
[Cloth Physics Simulation](../../../physics/cloth/index.xhtml).

[image reference removed]

This has various advantages but is especially useful for base mesh creation and larger clothing folds and draping.
Detailing is possible, but the slower performance on high resolution meshes and simplified cloth physics
might not lead to desirable results.

The resolution of the topology is mainly responsible for the size of the folds
and detail level of the simulation. So an optimal and evenly distributed topology is important.

Many sculpting features are supported, so for example [Masked](../editing/mask.xhtml#sculpt-mask-menu) vertices
are [pinned](../../../physics/cloth/settings/shape.xhtml) in the simulation.
Another example is with [auto-masked](../controls.xhtml) face set boundaries.
The sculpt mode [gravity](../tool_settings/options.xhtml#bpy-types-sculpt-gravity) factor is also applied on the cloth physics.

The main brushes and tools for this feature are the [Cloth Brush](../brushes/cloth.xhtml)
and [Cloth Filter](../tools/cloth_filter.xhtml),
but other transform brushes like [Pose](../brushes/pose.xhtml) and
[Boundary](../brushes/boundary.xhtml) also support cloth sculpting in the brush settings.

A demo file for trying out the various brushes and tools is available
[here](https://www.blender.org/download/demo-files/#sculpting).
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Source
:   The source of the Cryptomatte image.

    Render:
    :   Use the Cryptomatte render passes of a certain View Layer.

    Image:
    :   Use a Cryptomatte image from multilayered OpenEXR file.

Scene
:   Scene from which to take the Cryptomatte.
    Only available when Source is set to *Render*.

Image
:   Image to use for the Cryptomatte.
    Only available when Source is set to *Image*.

Cryptomatte Layer
:   The image layer to use. This is typically a combination of a View Layer and a Cryptomatte
    type (Object/Material/Asset).

Matte ID
:   The comma-separated names of the objects or materials for which to create a mask.
    While these can be typed manually, it’s easier to use the + and - buttons
    next to the textbox; see [Typical Usage](#typical-usage) below.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Mode
:   Whether to update left or right or both handles.
    When both are selected, both the left and the right handles will be updated.

    Left:
    :   Update the left handles.

    Right:
    :   Update the right handles.

Handle Type
:   The handle type to switch to. See the [Bézier curves](../../../curves/structure.html#curve-bezier-handle-type)
    page for more details on the different handle types.
user: What is Keyboard and how is it used in Blender Python scripting?

assistant: Emulate Numpad
:   The Numpad keys are used quite often in Blender and are not assigned to the same action as
    the regular number keys. If you have a keyboard without a Numpad (e.g. on a laptop),
    you can tell Blender to treat the standard number keys as Numpad keys by checking *Emulate Numpad*.

Default to Advanced Numeric Input
:   For transform mode, default to [Advanced Mode](../../scene_layout/object/editing/transform/control/numeric_input.html#transform-numeric-input-advanced),
    otherwise [Simple Mode](../../scene_layout/object/editing/transform/control/numeric_input.html#transform-numeric-input-simple) is used.
user: Show practical ways to work with Sticky Selection Mode in a Blender add-on or script – include code.

assistant: Options for automatically selecting additional UV vertices.
Only available for *Face* select mode or if *Sync Selection* is disabled.

Disabled
:   Each UV vertex can be selected independently of the others.

Shared Location
:   Automatically select UV vertices that correspond to the same mesh vertex and have the same UV coordinates.
    This is the default and gives the illusion that multiple faces in a UV map can share the same vertex;
    in reality, they have separate vertices that overlap.

Shared Vertex
:   Automatically select UV vertices that correspond to the same mesh vertex,
    even if they have different UV coordinates.
    This is also the behavior when *Sync Selection* is enabled.
user: What is Keying Sets and how is it used in Blender Python scripting?

assistant: # Keying Sets

[image reference removed]

The Active Keying Sets data ID in the Timeline.

Keying Sets are a collection of animated properties that are used to animate
and keyframe multiple properties at the same time.
For example, pressing `K` in the 3D Viewport will bring up the available Keying Sets.
Blender will then add keyframes for whichever Keying Set is chosen.
There are some built-in Keying Sets and also custom Keying Sets called “Absolute Keying Sets”.
user: Show practical ways to work with Working with Multiple Objects in a Blender add-on or script – include code.

assistant: # Working with Multiple Objects

Unlike Edit Mode, there is no multi-object editing supported for Sculpt Mode. Since sculpting often involves editing
many separate objects, it is recommended to use the shortcut `Alt` `Q` while pointing at other objects, for
[Switching Objects](../../../editors/3dview/modes.html#bpy-ops-object-transfer-mode) quickly.

[image reference removed]

The advantage of using multiple objects is that each can have its own origin and modifiers.
Splitting the geometry among multiple objects can also improve the sculpt mode performance.
Alternatively objects can also be [joined](../../../scene_layout/object/editing/join.html)
so there is no need to switch objects.

[image reference removed]

In the case that Face Sets were already used, joining objects or creating new geometry in Edit Mode will
automatically assign new Face Sets. This makes it immediately possible to target each new geometry, for example via
auto-masking. If no Face Sets are created, use the [Initialize Face Sets](../editing/face_sets.html#bpy-ops-sculpt-face-sets-init) operator to create them.

Face Sets and Masked geometry can also be extracted via [Mask Extract](../editing/mask.html#bpy-ops-sculpt-paint-mask-extract)
or sliced into a new object via [Mask Slice](../editing/mask.html#bpy-ops-sculpt-paint-mask-slice).
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image
:   Standard color input.

Mask
:   Controls the amount of influence the node exerts on the output image.

### Master

These settings target the entire tonal range.

Saturation
:   Adjusts the image’s saturation.

Contrast
:   Adjust image contrast.

Gamma
:   Exponential gamma correction, affecting the midtones of the image. (Works like Power in the Color Balance node.)

Gain
:   Multiplier, stronger influence on the highlights. (Works like Slope in the Color Balance node.)

Offset
:   This value (can be negative) will be added (+), linear lightens or darkens the image.

### Highlights / Midtones / Shadows

These settings target specific brightness ranges of the image.

Each tonal range (Highlights, Midtones, Shadows) supports the same controls as Master.

### Tonal Ranges

Midtones Start, Midtones End
:   Defines the start and the end of midtones range, i.e.
    values where the whole tonal range is divided into the highlights, midtones and shadows
    (there is also a smooth transition between the ranges of width 0.2 units).

### Channels

Red, Green, Blue
:   Specifies which RGB channels will be affected by the correction.
user: Show practical ways to work with Spline Resolution Node in a Blender add-on or script – include code.

assistant: # Spline Resolution Node

[image reference removed]

The *Spline Resolution* outputs the number of evaluated curve points that will be generated for
every control point on the spline. This node works for NURBS, Bézier, and Catmull Rom splines.

For poly splines, there is a one-to-one correspondence between original points and evaluated points,
so the resolution does not have an effect.

On Bézier splines, the resolution does not have an effect on segments between vector handles,
since there are no extra evaluated points between the neighboring control points.

The node to set this data is the [Set Spline Resolution Node](../write/set_spline_resolution.xhtml).
user: Show practical ways to work with TextureNodeSeparateColor(TextureNode) in a Blender add-on or script – include code.

assistant: # TextureNodeSeparateColor(TextureNode)

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

*class* bpy.types.TextureNodeSeparateColor(*TextureNode*)
:   mode
    :   Mode of color processing

        Type:
        :   enum in [Node Combsep Color Items](bpy_types_enum_items/node_combsep_color_items.html#rna-enum-node-combsep-color-items), default `'RGB'`

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

assistant: The compositor only supports a single active output target, that is, only one of the
[Group Output nodes](types/output/group_output.xhtml) or [Viewer nodes](types/output/viewer.xhtml#bpy-types-compositornodeviewer) in the node tree will be considered active and the rest will be
ignored. In particular, the compositor searches the *Active Node Tree Context* and falls back to the
*Root Node Tree Context* if no active output was found in the active node tree context. The active
node tree context is the node tree of an expanded node group, that is, when the user selects a node
group node and edits its underlying tree, while the root node tree context is the top level node
tree without any expanded node groups.

The compositor searches for the active *Group Output* node, if none was found, it searches for the
active *Viewer* node. If none was found, the compositor doesn’t run altogether.
Consequently, note that adding a *Viewer* node will have no effect on the viewport render if there
is a *Group Output* node, since the priority is given to *Group Output* nodes.
user: Show practical ways to work with Bounces in a Blender add-on or script – include code.

assistant: In reality light will bounce a huge number of times due to the speed of light being very high.
In practice more bounces will introduce more noise, and it might be good to use something like
the Limited Global Illumination preset in the [Light Paths](../render_settings/light_paths.html#render-cycles-integrator-light-paths)
Section that uses *fewer* bounces for different shader types.
Diffuse surfaces typically can get away with fewer bounces,
while glossy surfaces need a few more,
and transmission shaders such as glass usually need the most.

|  |  |  |
| --- | --- | --- |
| <../../../_images/render_cycles_optimizations_reducing-noise_0bounce.jpg>   No bounces. | <../../../_images/render_cycles_optimizations_reducing-noise_2bounce.jpg>   Two bounces at max. | <../../../_images/render_cycles_optimizations_reducing-noise_4bounce.jpg>   Four bounces at max. |

Also important is to use shader colors that do **not** have components of value 1.0 or
values near that; try to keep the maximum value to 0.8 or less and make your lights brighter.
In reality, surfaces are rarely perfectly reflecting all light,
but there are of course exceptions; usually glass will let most light through,
which is why we need more bounces there. High values for the color components tend to
introduce noise because light intensity then does not decrease much as it bounces off each
surface.
user: Give a detailed overview of Create Guide Index Map: syntax, arguments, return values, common patterns.

assistant: # Create Guide Index Map

The *Create Guide Index Map* node generates an integer attribute named
`guide_curve_index` that maps every hair curve to its nearest *guide* curve.
Each non-guide curve is assigned the index of the guide curve it should follow.

This guide map is used by other hair grooming nodes (for example,
[Braid Hair Curves](braid_hair_curves.xhtml),
[Clump Hair Curves](clump_hair_curves.xhtml))
to organize curves into logical groups around shared guides and apply
effects consistently.

Other nodes in the [Hair Guides Nodes](index.xhtml)
category can generate a guide map internally for convenience, but the
resulting attribute is equivalent to what this node produces.
user: Describe Troubleshooting Linux – Intel from the Blender manual or Python API, including usage steps and snippets.

assistant: # Troubleshooting Linux – Intel

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Describe Burn into Image from the Blender manual or Python API, including usage steps and snippets.

assistant: Add metadata as text to the render.

Font Size
:   Set the size of the text.

Text Color
:   Set the color and alpha of the stamp text.

Background
:   Set the color and alpha of the color behind the text.

Include Labels
:   Displays the labels before the metadata text. For example,
    “Camera” in front of the camera name, etc.
user: Provide the full official documentation entry for FunctionNodeCombineMatrix(FunctionNode), preserving all code examples.

assistant: # FunctionNodeCombineMatrix(FunctionNode)

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

*class* bpy.types.FunctionNodeCombineMatrix(*FunctionNode*)
:   Construct a 4x4 matrix from its individual values

    *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 Render Region in complete detail according to the official Blender documentation.

assistant: Allows you to limit rendering to a 2D rectangular area. If you’re busy tweaking
just a small part of the scene, it can be quite wasteful to have the whole viewport in
[Rendered shading mode](../display/shading.xhtml#view3d-viewport-shading) or make full-frame renders,
so this feature lets you save time.

You can define Render Regions in two different contexts:

- If you define one while in [Camera View](camera_view.xhtml),
  it will apply not just to the viewport, but also to the final render.
  If you want to temporarily disable this region rather than clearing it entirely,
  you can do so in the Output tab of the [Properties](../../../render/output/properties/format.xhtml#bpy-types-rendersettings-use-border) editor.
- If you define one while not in Camera View, it will only apply to the viewport.
  If you want to temporarily disable this region rather than clearing it entirely,
  you can do so in the [Sidebar](../sidebar.xhtml#bpy-types-spaceview3d-use-render-border).

Both Render Regions can exist at the same time.

Render region and associated render.

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_regions_render-border-1.png | ../../../_images/editors_3dview_navigate_regions_render-border-2.png |
user: Describe Proportional Editing from the Blender manual or Python API, including usage steps and snippets.

assistant: # Proportional Editing

[[image reference removed]](../../../_images/editors_3dview_controls_proportional-editing_tool.png)

Proportional Editing popover.

Proportional Editing is a way of transforming selected elements while also affecting
the nearby unselected elements. The farther away an unselected element is, the less it will be affected
(hence the “proportional”). This feature is very useful for smoothly deforming dense meshes.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Limit Scale constraint.

Minimum/Maximum X, Y, Z
:   The number fields determine the boundaries for each axis.
    The checkboxes determine whether each boundary applies.

Affect Transform
:   When the owner is manually scaled, restrict not just its
    [visual](../introduction.xhtml#constraint-visual-transform) scale but also its
    *Scale* in the [Properties Editor](../../../editors/properties_editor.xhtml)’s *Transform* panel.

[Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The space for determining and limiting the scale of the owner.

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

assistant: # Separate Spherical Node

[image reference removed]

The *Separate Spherical* node converts a vector from Cartesian coordinates (X, Y, Z)
into spherical coordinates (R, Φ, Θ) and outputs each component separately.
It is the inverse of the [Combine Spherical](combine_spherical.xhtml) node.

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: How do I use Baking in Blender? Include parameters, examples, warnings and best practices.

assistant: # Baking

Baking allows saving and loading intermediate geometries.
Baking parts of the node tree can be used for better performance.

The data format used to store geometry data is not considered to be an import/export format.
Volume objects, however, are saved using the OpenVDB file format which can be used interoperably.

Data can be baked using two methods:

- [Bake Node](geometry/operations/bake.xhtml) – used to bake any portion of the node tree.
- [Simulation Zone Baking](simulation/simulation_zone.xhtml#geometry-nodes-simulation-baking) –
  used to bake animations where the result of one geometry state can influence the next state.

Data is not stored to disk until the [Bake](#bpy-ops-object-geometry-node-bake-single) operation is ran.
user: Describe The Blender Community from the Blender manual or Python API, including usage steps and snippets.

assistant: # The Blender Community

Being freely available from the start, even while it was closed source, considerably helped Blender’s adoption by the
community. A large, stable, and active community of users has gathered around Blender since 1998. The community showed
its support for Blender in 2002 when they helped raise €100,000 in seven weeks to enable Blender to go Open Source
under the [GNU GPL License](https://www.gnu.org/licenses/gpl.html).
user: How do I use SpaceImageOverlay(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SpaceImageOverlay(bpy_struct)

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

*class* bpy.types.SpaceImageOverlay(*bpy_struct*)
:   Settings for display of overlays in the UV/Image editor

    passepartout_alpha
    :   Opacity of the darkened overlay outside the render region

        Type:
        :   float in [0, 1], default 0.5

    show_grid_background
    :   Show the grid background and borders

        Type:
        :   boolean, default False

    show_overlays
    :   Display overlays like UV Maps and Metadata

        Type:
        :   boolean, default False

    show_render_size
    :   Display the region of the final render

        Type:
        :   boolean, default False

    show_text_info
    :   Display overlay text

        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: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: See below for the result of using *Shear* on a number of different elements.

[image reference removed]

The effects of a Shear transform with different Pivot Points.

The three frames of the image above show the effects of shearing
on the selected vertices when the pivot point is altered.
In middle frame, the [Pivot Point](../../../../../editors/3dview/controls/pivot_point/index.xhtml)
is set to *Median Point* and the mouse was moved to the left during the transform.
In right frame, the *Pivot Point* is set to the 3D cursor which is located above the mesh.
When the mouse is moved to the left during a *Shear* transform,
the selected vertices are moved to the right as they are below the horizontal axis.

[image reference removed]

The effects of a Shear transform on objects with different Pivot Points.
user: Explain ShaderNodeUVMap(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeUVMap(ShaderNode)

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

*class* bpy.types.ShaderNodeUVMap(*ShaderNode*)
:   Retrieve a UV map from the geometry, or the default fallback if none is specified

    from_instancer
    :   Use the parent of the instance object if possible

        Type:
        :   boolean, default False

    uv_map
    :   UV coordinates to be used for mapping

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Text boxes (or frames) allow you to distribute the text among rectangular areas within a single text object.
An arbitrary number of freely movable and re-sizable text frames are allowed per text object.

The text flows continuously from the lowest-numbered frame to the highest-numbered frame with text
inside each frame word-wrapped.
It flows between frames when a lower-numbered frame cannot fit any more text.
If the last frame is reached, text overflows out of it (by default, see options below).

[image reference removed]

Text Boxes panel.

Add Textbox
:   Inserts a new frame, just after the current one (in text flow order).
    The new frame will have the same size and position as the selected one.

(Remove Text Block)
:   Delete the current frame.

Overflow
:   How to handle text overflowing available space in the defined boxes.

    Overflow:
    :   Just keep text running out of the last box.

    Scale to Fit:
    :   Scale text to fit into the available space.

    Truncate:
    :   Hide the end of the text that does not fit into the available space.

Size X, Y
:   Specifies the width and height of the text box, if set to **zero** no word wrapping happens
    (it is ignored, and the whole text box system is disabled if all are set to a null size).

Offset X, Y
:   Controls the *X* and *Y* offset of the frame, i.e. its position.

[image reference removed]

Multiple columns, text flowing between boxes.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: |  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bevel_example-5.png   Result of beveling multiple edges. | ../../../../_images/modeling_meshes_editing_edge_bevel_example-6.png   Another example of beveling multiple edges. | ../../../../_images/modeling_meshes_editing_edge_bevel_example-7.png   An example using Profile=0.150. |
user: Give a detailed overview of Subdivide Curve Node: syntax, arguments, return values, common patterns.

assistant: # Subdivide Curve Node

[image reference removed]

The *Subdivide Curve* node adds more control points in between existing control points on the curve input.
For Bézier and poly splines, the shape of the spline will not be changed at all.

With Bézier curves, this can be used to increase the control on the shape of the curve
while still having the higher-level provided by Bézier splines.
Unlike the [Resample Curve Node](resample_curve.html), where they are converted to poly splines.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Scopes.histogram`](bpy.types.Scopes.html#bpy.types.Scopes.histogram "bpy.types.Scopes.histogram") | - [`SpaceImageEditor.sample_histogram`](bpy.types.SpaceImageEditor.html#bpy.types.SpaceImageEditor.sample_histogram "bpy.types.SpaceImageEditor.sample_histogram") |
user: What is Brush Settings and how is it used in Blender Python scripting?

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.html)
:   General and advanced settings.

[Texture](../../brush/texture.html)
:   Color and mask texture settings.

[Stroke](../../brush/stroke.html)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.html)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.html)
:   Cursor and appearance settings.
user: Provide the full official documentation entry for ThemeCollectionColor(bpy_struct), preserving all code examples.

assistant: # ThemeCollectionColor(bpy_struct)

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

*class* bpy.types.ThemeCollectionColor(*bpy_struct*)
:   Theme settings for collection colors

    color
    :   Collection Color Tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type