PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with ThemeGraphEditor(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeGraphEditor(bpy_struct)

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

*class* bpy.types.ThemeGraphEditor(*bpy_struct*)
:   Theme settings for the graph editor

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

    space
    :   Settings for space

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

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

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

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

    vertex_size
    :   Type:
        :   int in [1, 32], default 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: Explain Bake Node in complete detail according to the official Blender documentation.

assistant: # Bake Node

[image reference removed]

The *Bake* node allows saving and loading intermediate geometries.
This node bakes parts of the node tree 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.
user: How do I use Header in Blender? Include parameters, examples, warnings and best practices.

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

[image reference removed]

Common node editor header options.

View
:   This menu changes your view of the editor.

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

Add
:   This menu allows you to add nodes.

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

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

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

Snapping
:   Change options for snapping node positions to achieve a cleaner node tree layout.
    See [Arranging Nodes](arranging.xhtml).
user: Describe Updating on Linux from the Blender manual or Python API, including usage steps and snippets.

assistant: On Linux there are two ways to update Blender. This section covers the most common approaches.

### Updating from blender.org

When an update for Blender is released, it can be downloaded directly from the
[Blender website](https://www.blender.org/download/) and installed using the steps described in the section
[Install from blender.org](#install-from-blender-org).

### Updating with a Package Manager

Many Linux distributions have packages for Blender available, which can be installed using the distribution’s package
manager. After installation, Blender can be updated using the same steps as updating any other application.
user: Describe Children from the Blender manual or Python API, including usage steps and snippets.

assistant: # Children

*Children* are *Hair* or *Emitter* particles originating from individual particles.
They make it possible to work primarily with a relatively low amount of Parent particles,
for whom the physics are calculated. The children are then aligned to their parents.
The number and visualization of the children can be changed without a recalculation of the physics.

If you activate children, the parents are no longer rendered. This can be enabled in the Render panel
[Parent Particles](render.xhtml#bpy-types-particlesettings-use-parent-particles). By default, parent particles
are not rendered because the shape of the children can be quite different from that of their parents.
user: Give a detailed overview of Skin Resize: syntax, arguments, return values, common patterns.

assistant: # Skin Resize

This tool is used to set a skin radius per vertex when using
a [Skin Modifier](../../../../modifiers/generate/skin.xhtml).
Non-uniform scaling of the X and Y axes is accessible by the usual axis locking
with `X` or `Y`. The radius can also be adjusted in the *Transform* panel of
the Sidebar, in the 3D Viewport. The mean radius of all vertices can be previewed
in the 3D Viewport as a dashed circle around a vertex.

[image reference removed]

Simple creature, made with only the Skin and Subdivision Surface modifiers.
user: Give a detailed overview of NodeSocketClosure(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketClosure(NodeSocketStandard)

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

*class* bpy.types.NodeSocketClosure(*NodeSocketStandard*)
:   Closure socket of a node

    links
    :   List of node links from or to this socket.

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

        (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: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Bilateral smoothed Ambient Occlusion.
[blend-file example](https://archive.blender.org/wiki/2015/uploads/2/2a/Bilateral_blur_example_01.blend)

|  |  |
| --- | --- |
| ../../../../_images/compositing_types_filter_bilateral-blur_example-1-render.jpg   Render result. | ../../../../_images/compositing_types_filter_bilateral-blur_example-1-composite.jpg   Composite. |
user: Describe Advanced Mode from the Blender manual or Python API, including usage steps and snippets.

assistant: In advanced mode you can additionally enter expressions and units.

Use `=` or `NumpadAsterisk` to enable advanced mode,
and `Ctrl`-`=` or `Ctrl`-`NumpadAsterisk` to switch back to simple mode.

It features:

- Units (`cm`, `"`, `deg`, etc.).
  See [unit system](../../../../scene/properties.html#bpy-types-unitsettings).
- Basic operations from Python (`+`, `*`, `/`, `**`, etc.).
- Math constants and functions (`pi`, `sin`, `sqrt`, etc.).
  See Python’s [math](https://docs.python.org/3.8/library/math.html) module.

You can still use the negate and inverse shortcuts (`Minus`, `Slash`),
as well as non-number inputs, but you have to hold `Ctrl` to activate them.
user: Provide the full official documentation entry for Controls, preserving all code examples.

assistant: These keyboard shortcuts are shown in the
[status bar](../../../../interface/window_system/status_bar.xhtml) while cutting.
They’re available both when using the tool from the Toolbar and when pressing `K`.

Cut `LMB`
:   You can either click to add a new cutting line, or drag to create cutting lines
    as you move the mouse over edges.

Close Loop - Double-click `LMB`
:   Adds a cutting point at the cursor (just like when single-clicking) and then connects
    it to the first point in the current path, closing the loop.

Stop `RMB`
:   Completes the current cutting path and begins a new one. The cursor will snap to previously
    defined cuts.

    |  |  |
    | --- | --- |
    | ../../../../_images/modeling_meshes_tools_knife_multiple-before.png   After defining the horizontal cut, press `RMB` and define the vertical one. | ../../../../_images/modeling_meshes_tools_knife_multiple-after.png   Result after applying. |

Confirm `Spacebar` or `Return`
:   Confirms the cut, turning the cutting paths into edges.

Cancel `Esc`
:   Cancels the cut.

Undo `Ctrl`-`Z`
:   Undoes the previous cutting line (or, if you dragged the mouse before, all the cutting
    lines created during that drag).

Midpoint Snap `Shift`
:   Hold to snap the cursor to the center of edges.

Ignore Snap `Ctrl`
:   Hold to temporarily stop the cursor from snapping to existing vertices, edges,
    and cutting lines.

Cut Through `C`
:   Also cut through occluded faces, instead of only the visible ones.
    This is linked to (and the opposite of) the *Occlude Geometry* setting above.

Axis `X`, `Y`, or `Z`
:   Constrains the current cutting line to a global axis. Press a second time to use the
    object’s local axis, and a third time to disable the constraint again.

Measure `S`
:   Cycles between measurements to show: distances, angles, or both.

X-Ray `V`
:   Toggles whether to display cuts occluded by geometry.

Angle Constraint `A`
:   Constrains cutting lines to multiples of the *Snap Increment* angle. This angle
    can be specified in the Tool Settings before cutting (see above) or typed
    while cutting with *Angle Constraint* active.

    By default, the snapping is done in the *Screen* plane. Press `A`
    a second time to snap in planes on the geometry, *Relative* to an automatically
    chosen edge or cutting line. You can press `R` to select a different reference line.

    Press `A` a third time to disable the snapping again.
user: Show practical ways to work with Select Menu in a Blender add-on or script – include code.

assistant: All `A`
:   Select all.

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

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

---

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

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

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

---

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

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

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

---

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

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

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

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

---

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

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

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

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

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

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

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

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

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

Side of Active
:   Selects all vertices on the mesh in a single axis relative to the active vertex.
    In Vertex selection mode only.
user: Give a detailed overview of Geometry: syntax, arguments, return values, common patterns.

assistant: Offset
:   Offset the control points of the curves defining the letters, which will make them thinner or thicker.
    Use with care, it can quickly lead to artifacts…

### Extrusion, Taper & Bevel

The remaining settings of that panel, which are used to give volume to the letters,
are also shared with the [Curves](../curves/properties/geometry.html) data-blocks,
please refer to those for details.
user: Show practical ways to work with CurvesSculpt(Paint) in a Blender add-on or script – include code.

assistant: # CurvesSculpt(Paint)

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

*class* bpy.types.CurvesSculpt(*Paint*)
:   *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 Strip Scale Method Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Strip Scale Method Items

FIT:
:   Scale to Fit.

    Fits the image bounds inside the canvas, avoiding crops while maintaining aspect ratio.

FILL:
:   Scale to Fill.

    Fills the canvas edge-to-edge, cropping if needed, while maintaining aspect ratio.

STRETCH:
:   Stretch to Fill.

    Stretches image bounds to the canvas without preserving aspect ratio.

ORIGINAL:
:   Use Original Size.

    Display image at its original size.
user: What is Custom Properties and how is it used in Blender Python scripting?

assistant: Custom properties can also be assigned to point cloud objects themselves.
These properties are stored at the object level and not per point.

See the [Custom Properties](../../files/custom_properties.xhtml#files-data-blocks-custom-properties)
documentation for more information on how to add and use them.
user: Describe About Free Software and the GPL from the Blender manual or Python API, including usage steps and snippets.

assistant: # About Free Software and the GPL

[image reference removed]

When one hears about “free software”, the first thing that comes to mind might be “no cost”. While this is often true,
the term “free software” as used by the Free Software Foundation (originators of the GNU Project and creators of the
GNU General Public License) is intended to mean “free as in freedom” rather than in the sense of “no cost” (which is
usually referred to as “free as in free beer” or *gratis*). Free software in this sense is software which you are free
to use, copy, modify, redistribute, with no limit. Contrast this with the licensing of most commercial software
packages, where you are allowed to load the software on a single computer, are allowed to make no copies, and never
see the source code. Free software allows incredible freedom to the end user. Since the source code is universally
available, there are also many more chances for bugs to be caught and fixed.

When a program is licensed under the GNU General Public License (the GPL):

- You have the right to use the program for any purpose.
- You have the right to modify the program and have access to the source codes.
- You have the right to copy and distribute the program.
- You have the right to improve the program, and release your own versions.

In return for these rights, you have some responsibilities if you distribute a GPL’d program. These responsibilities
are designed to protect your freedoms and the freedoms of others:

- You must provide a copy of the GPL with the program, so that recipients are aware of their rights under the license.
- You must include the source code or make the source code freely available.
- If you modify the code and distribute the modified version, you must license your modifications available under the
  GPL (or a compatible license).
- You may not restrict the licensing of the program beyond the terms of the GPL (you may not turn a GPL’d program into
  a proprietary product).

For more on the GPL, check its page on the [GNU Project website](https://www.gnu.org/licenses/licenses.html#GPL).
user: What is Viewport Display and how is it used in Blender Python scripting?

assistant: # Viewport Display

Thickness
:   Factor that scales the thickness of the grid that is currently being displayed.

Interpolation
:   Interpolation method to use for the visualization of the fluid grid.

    Linear:
    :   Linear interpolation between voxels. Gives good smoothness and speed.

    Cubic:
    :   Cubic interpolation between voxels. Gives smoothed high quality interpolation, but is slower.

    Closest:
    :   No interpolation between voxels. Gives raw voxels.

Slice per Voxel
:   Determines how many slices per voxel should be generated.
user: What is Collisions and how is it used in Blender Python scripting?

assistant: Quality
:   A general setting for how fine and good a simulation you wish.
    Higher numbers take more time but ensure less tears and penetrations through the hair.

Distance
:   The distance another object must get to the hair for
    the simulation to repel the hair out of the way.
    Smaller values might cause errors but provide some speed-up while
    larger will give unrealistic results if too large and can be slow.
    It is best to find a good in between value.

Impulse Clamping
:   Prevents explosions in tight and complicated collision situations
    by restricting the amount of movement after a collision.

Collision Collection
:   Only objects that are a part of this [Collection](../../../scene_layout/collections/index.xhtml)
    can collide with the hair. Note that these objects must also have Collision physics enabled.
user: Explain Admonitions in complete detail according to the official Blender documentation.

assistant: Admonitions are special blocks used to highlight important notes, warnings,
or additional information in the documentation.

Common admonition types include:

- `note`
- `tip`
- `important`
- `warning`
- `caution`
- `seealso`

Admonitions are created using the following markup:

```
.. note::

   This is a note for general information.
```

Other types can be rendered by replacing `note` with the desired type from the list above.
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

Grease Pencil has a special set of viewport real-time visual effects that can be apply to the object.

These effects treat the object as if it was just an image, for that reason they
have effect on the whole object and cannot limit their influence
on certain parts like layers, materials or vertex group as with modifiers.
Also unlike modifiers, they can not be applied to the object.

Their main purpose is to have a quick way to apply visual effects on your drawings
like blurring, pixelation, wave distortion, among others.
user: Show practical ways to work with Custom Range in a Blender add-on or script – include code.

assistant: When working with volume objects, EEVEE automatically computes the best depth range where to compute
the volume sampling and lighting.
In certain situations, this isn’t enough and produces sub-optimal sampling which increases noise.
This is particularly the case when using a volume shader inside the *World* or when working with large
number of volume objects.
The custom depth range can be enabled to restrict the computation of volumes to a certain range along
the camera depth and thus increase precision.

Start
:   Start distance of the volumetric effect.

End
:   End distance of the volumetric effect.
user: Provide the full official documentation entry for Property Flag Items, preserving all code examples.

assistant: # Property Flag Items

READ_ONLY:
:   Read Only.

    When set, the property cannot be edited.

HIDDEN:
:   Hidden.

    For operators: hide from places in the user interface where Blender would add the property automatically, like Adjust Last Operation. Also this property is not written to presets..

SKIP_SAVE:
:   Skip Save.

    For operators: the value of this property will not be remembered between invocations of the operator; instead, each invocation will start by using the default value. Also this property is not written to presets..

SKIP_PRESET:
:   Skip Preset.

    Do not write in presets.

ANIMATABLE:
:   Animatable.

LIBRARY_EDITABLE:
:   Library Editable.

    This property can be edited, even when it is used on linked data (which normally is read-only). Note that edits to the property will not be saved to the blend file..

PROPORTIONAL:
:   Adjust values proportionally to each other.

TEXTEDIT_UPDATE:
:   Update on every keystroke in textedit ‘mode’.

OUTPUT_PATH:
:   Output Path.

PATH_SUPPORTS_BLEND_RELATIVE:
:   Relative Path Support.

    This path supports relative prefix “//” which is expanded the directory where the current “.blend” file is located..

SUPPORTS_TEMPLATES:
:   Variable expression support.

    This path supports the “{variable_name}” template syntax, which substitutes the value of the referenced variable in place of the template expression.
user: Describe Brush from the Blender manual or Python API, including usage steps and snippets.

assistant: # Brush

Tool to use for any of the *Sculpt* mode brushes. Activating a brush from an asset shelf or brush
selector will also activate this tool for convenience.

See the list of [Essentials Brushes](../brushes/brushes.xhtml)
(based on available [Brush Types](../brushes/index.xhtml)) for more details.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: ### Visibility Management

Each [Scene](../../scene_layout/scene/introduction.html) consists of one or more
[Collections](../../scene_layout/collections/collections.html).
Collections can be enabled or disabled per View Layer, allowing you to control what appears in each layer’s render.

This makes it easy to separate lighting, characters, props, or effects into their own passes.

Collection visibility for each View Layer can be adjusted in the [Outliner](../../editors/outliner/editing.html#editors-outliner-editing-collections) or [Collection View Layer Properties](../../scene_layout/collections/collections.html#bpy-types-layercollection).

[image reference removed]

View Layer collections in the Outliner.

From the Outliner, you can:

- Enable or disable collections per View Layer.
- Set holdout and indirect-only options (Cycles only).
- Manage what objects contribute to the render or compositing.

### Rendering & Compositing

When a scene is rendered, each View Layer is available in the
[Compositor](../../compositing/introduction.html) using they [Render Layers Node](../../compositing/types/input/scene/render_layers.html).
This allows you to process each layer independently, combining or adjusting them to create the final output.

Each View Layer can output multiple [Render Passes](passes.html) including:

- Combined (final image)
- Diffuse, Glossy, Transmission components
- Shadow, Mist, Ambient Occlusion
- Cryptomatte and Object/Material/ID Masks
- Data passes like Normal, UV, and Depth

These passes make it possible to perform detailed color grading,
masking, relighting, and other post-processing operations in a non-destructive workflow.
user: Describe Terminology from the Blender manual or Python API, including usage steps and snippets.

assistant: BSDF
:   Stands for Bidirectional Scattering Distribution Function.
    It defines how light is reflected and refracted at a surface.

Reflection
:   BSDFs reflect an incoming ray on the same side of the surface.

Transmission
:   BSDFs transmit an incoming ray through the surface, leaving on the other side.

Refraction
:   BSDFs are a type of *Transmission*, transmitting an incoming ray and
    changing its direction as it exits on the other side of the surface.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`XrActionMapBinding.component_paths`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding.component_paths "bpy.types.XrActionMapBinding.component_paths") - [`XrComponentPaths.find`](bpy.types.XrComponentPaths.html#bpy.types.XrComponentPaths.find "bpy.types.XrComponentPaths.find") | - [`XrComponentPaths.new`](bpy.types.XrComponentPaths.html#bpy.types.XrComponentPaths.new "bpy.types.XrComponentPaths.new") - [`XrComponentPaths.remove`](bpy.types.XrComponentPaths.html#bpy.types.XrComponentPaths.remove "bpy.types.XrComponentPaths.remove") |
user: Explain GeometryNodeInstanceOnPoints(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInstanceOnPoints(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.GeometryNodeInstanceOnPoints(*GeometryNode*)
:   Generate a reference to geometry at each of the input points, without duplicating its underlying data

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Closure and how is it used in Blender Python scripting?

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Describe FloatVectorValueReadOnly(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FloatVectorValueReadOnly(bpy_struct)

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

*class* bpy.types.FloatVectorValueReadOnly(*bpy_struct*)
:   vector
    :   3D vector

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Brush Waves panel.

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

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

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

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

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

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

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

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

Clamp Waves
:   In some cases the brush goes very deep inside the surface messing whole simulation up.
    You can use this setting to “limit” influence to only certain depth.
user: What is Creating the Language Entry in the HTML Menu and how is it used in Blender Python scripting?

assistant: 1. Create an entry for the language in the html menu by opening file `./build_files/theme/js/version_switch.js`
   (assuming you are at the `blender-manual` subdirectory).
2. Find the table for the languages in `var all_langs = {..};`.
3. Add the entry: `"fr": "Fran&ccedil;ais",`, (`"fr": "Français"`). (Notice the Unicode characters.)
4. Commit the updated file:

   ```
   git add ./build_files/theme/js/version_switch.js
   git commit -m "HTML: Add French to language menu"
   ```
5. Push your changes to the upstream repository:

   ```
   git push
   ```
user: Show practical ways to work with Editing Tools in a Blender add-on or script – include code.

assistant: # Editing Tools

[image reference removed]

[Select](../../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or moved.

    [Select Box](../../../../interface/selecting.xhtml#tool-select-box)
    :   Select geometry by dragging a box.

    [Select Circle](../../../../interface/selecting.xhtml#tool-select-circle)
    :   Select geometry by painting on it.

    [Select Lasso](../../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select geometry by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Pen](pen.xhtml#tool-grease-pencil-edit-pen)
:   Tool for creating and modifying [Bézier](../../../../modeling/curves/structure.xhtml#curve-spline-types) strokes.

Radius `Alt`-`S`
:   Expand or contract the thickness radius of the selected points.

Bend `Shift`-`W`
:   Bend selected points between the 3D cursor and the pointer.

Shear `Shift`-`Ctrl`-`Alt`-`S`
:   Shear selected points along the horizontal or vertical screen axis.

    To Sphere `Shift`-`Alt`-`S`
    :   Move selected points outward in a spherical shape around the selected strokes’ center.

[Interpolate](../../draw/tools/interpolate.xhtml#tool-grease-pencil-draw-interpolate) `Ctrl`-`E`
:   Automatically create a breakdown keyframe between two normal keyframes.

Gradient
:   Draw a line to set the fill material gradient for the selected strokes.

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

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

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

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

assistant: [image reference removed]

Combined with the [Geometry to Instance Node](../geometry_to_instance.xhtml),
this can be used to create a basic efficient “Array” operation. This should be more efficient
because the duplicates are [instances](../../instances.xhtml).

The “Duplicate Index” is used to move each instance in the result a different amount.
user: Describe Arrange from the Blender manual or Python API, including usage steps and snippets.

assistant: Change the drawing order of the strokes in the 2D layer.

Bring to Front
:   Moves to the top the selected points/strokes.

Bring Forward
:   Moves the selected points/strokes upper the next one in the drawing order.

Send Backward
:   Moves the selected points/strokes below the previous one in the drawing order.

Send to Back
:   Moves to the bottom the selected points/strokes.
user: Describe Common Problems from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Unsupported Graphics Driver Error

This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.

### Crash on Startup

Try running Blender from the [command line](../../../advanced/command_line/index.xhtml), to see if any helpful error messages
are printed.

On Windows, graphics drivers can sometimes get corrupted or incorrectly replaced by Windows Update. In this case, it
can help to uninstall all graphics drivers (there may be multiple sets installed from Intel, AMD and NVIDIA) and
perform a clean installation with drivers from the manufacturer’s website.

### Poor Performance

- Update your graphics drivers (see above).
- On laptops, make sure you are using a dedicated GPU (see above).
- Try lowering quality settings in Preferences ‣ System ‣ Memory & Limits.
- Try undoing settings in your graphics drivers, if you made any changes there.

### Render Errors

See [EEVEE](../../../render/eevee/limitations/index.xhtml) and [Cycles](../../../render/cycles/gpu_rendering.xhtml) documentation
respectively.

### Wrong Selection in 3D Viewport

See [Invalid Selection, Disable Anti-Aliasing](../../3d_view.xhtml#troubleshooting-3dview-invalid-selection).

### Virtual Machines

Running Blender inside a virtual machine is known to have problems when OpenGL drawing calls are forwarded to the host
operating system.

To resolve this, configure the system to use PCI passthrough.

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.
user: Provide the full official documentation entry for Gradient (Linear), preserving all code examples.

assistant: Applies a linear weight gradient;
this is useful at times when painting gradual changes in weight becomes difficult.
Blends the weights of selected vertices with unselected vertices.

[image reference removed]

Example of the Gradient tool being used with selected vertices.

Weight
:   The gradient starts at the current selected weight value, blending out to nothing.

Strength
:   Lower values can be used so the gradient mixes in with the existing weights (just like with the brush).

Type
:   The shape of the gradient.

    Linear:
    :   Create gradient that forms a straight line.

    Radial:
    :   Create gradient that forms a circle.
user: Explain Clouds in complete detail according to the official Blender documentation.

assistant: # Clouds

Clouds represent Perlin noise. In addition, each noise-based Blender texture
(with the exception of Voronoi and simple noise) has a *Noise Basis* setting that allows
the user to select which algorithm is used to generate the texture. This is often used for
Clouds, Fire, Smoke. Well-suited to be used as a Bump map, giving an overall irregularity to the material.

[image reference removed]

Clouds Texture panels.
user: Show practical ways to work with Independent Sites in a Blender add-on or script – include code.

assistant: There are [several independent websites](https://www.blender.org/community/) such as forums, blogs, news, and
tutorial sites dedicated to Blender.

One of the largest community forums is [Blender Artists](https://blenderartists.org/), where Blender users gather
to show off their creations, get feedback, ask and offer help and, in general, discuss Blender.
user: Provide the full official documentation entry for Smooth Vertices, preserving all code examples.

assistant: # Smooth Vertices

This operator smooths the selected vertices by averaging the angles between the faces.

Smoothing
:   Smoothing factor.

Repeat
:   The number of smoothing iterations.

Axes
:   Limit the effect to certain axes.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_modifiers_deform_smooth_mesh-before.png   Mesh before smoothing. | ../../../../_images/modeling_modifiers_deform_smooth_mesh-one-iteration.png   Mesh after one smoothing iteration. | ../../../../_images/modeling_modifiers_deform_smooth_mesh-ten-iterations.png   Mesh after ten smoothing iterations. |
user: Give a detailed overview of Hardware Limitations: syntax, arguments, return values, common patterns.

assistant: General hardware limitations apply when using the GPU compositor.
See also [Troubleshooting Graphics Hardware](../troubleshooting/gpu/index.xhtml#troubleshooting-gpu-index).

Blender uses the same GPU resources for the UI as well as for the GPU compositor.
This have a number of consequences, each of which is described in one of the following sections.

### UI Freezes

Unlike rendering with Cycles, the UI might become irresponsive when using the GPU compositor for some slower GPUs.

### TDR on Windows

Timeout Detection Recovery
([TDR](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/timeout-detection-and-recovery))
resets the GPU driver if a GPU compositing task takes longer than the default 2 second limit.
This is especially common with older GPUs when using expensive nodes like
[Bokeh Blur](types/filter/blur/bokeh_blur.xhtml#bpy-types-compositornodebokehblur) node.
To prevent unexpected resets, it is recommended to increase the TDR timeout.
user: Show practical ways to work with Cryptomatte in a Blender add-on or script – include code.

assistant: Cryptomatte is an image standard to efficiently create masks for specific objects or materials.
Its purpose is the same as the *Object Index* and *Material Index* passes,
but it has several advantages: it’s easier to set up, can be used with other
compositing software than Blender, and supports multiple objects per pixel.
Specifically, it works with transparency, as well as motion blur and depth of field
when using Cycles.

Object
:   Render cryptomatte passes for isolating objects.

Material
:   Render cryptomatte passes for isolating materials.

Asset
:   Render cryptomatte passes for isolating groups of objects with
    the same [parent](../../scene_layout/object/editing/parent.xhtml).
    This option is not related to Blender’s
    [asset](../../files/asset_libraries/introduction.xhtml) feature.

Levels
:   The maximum number of objects to be distinguished per pixel.
    The Render Layers node will output half this many Cryptomatte images,
    named (for example) *CryptoObject00*, *CryptoObject01* and so on –
    the reason being that one Cryptomatte image can reference two objects per pixel.

    The first image references, for each pixel, the two objects that contribute
    the most to that pixel’s color. The next image references the next two objects,
    and so on.
user: Show practical ways to work with Image Overlays in a Blender add-on or script – include code.

assistant: # Image Overlays

The Overlays pop-over configures the overlays that are displayed on top of images.
In the header, there is a button to turn off all overlays for the Image Editor.
This option also toggles the visibility of [UDIM](../../modeling/meshes/uv/workflows/udims.xhtml)
tile information.

The options that are visible in the pop-over depend on the Image Editor mode.
The following overlay categories are available:
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Curve.splines`](bpy.types.Curve.html#bpy.types.Curve.splines "bpy.types.Curve.splines") - [`CurveSplines.active`](bpy.types.CurveSplines.html#bpy.types.CurveSplines.active "bpy.types.CurveSplines.active") | - [`CurveSplines.new`](bpy.types.CurveSplines.html#bpy.types.CurveSplines.new "bpy.types.CurveSplines.new") - [`CurveSplines.remove`](bpy.types.CurveSplines.html#bpy.types.CurveSplines.remove "bpy.types.CurveSplines.remove") |
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: |  |  |
| --- | --- |
| ../../../_images/modeling_modifiers_generate_edge-split_example-1.png   Flat shading. | ../../../_images/modeling_modifiers_generate_edge-split_example-2.png   Smooth shading. |
| ../../../_images/modeling_modifiers_generate_edge-split_example-3.png   Smooth shading with Edge Split. | ../../../_images/modeling_modifiers_generate_edge-split_example-4.png   Smooth shading with Edge Split and Subdivision Surface. |
user: Explain NodeSocketFloatAngle(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketFloatAngle(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatAngle(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (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: Give a detailed overview of Noise Texture Node: syntax, arguments, return values, common patterns.

assistant: # Noise Texture Node

[image reference removed]

The *Noise Texture* node evaluates a fractal Perlin noise at the input texture coordinates.
It can be used for a single Perlin noise evaluation, or for combining multiple octaves
(layers) with increasingly finer detail.
user: Explain Who uses Blender? in complete detail according to the official Blender documentation.

assistant: Blender has a wide variety of tools making it suitable for almost any sort of media production. Professionals,
hobbyists, and studios around the world use it for creating animations, game assets, motion graphics, TV shows,
concept art, story-boarding, commercials, and feature films.

Check out the [User Stories page](https://www.blender.org/get-involved/user-stories/)
on the Blender website for more examples.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Selection
:   A boolean field input for each element indicating whether to store the attribute value for the given index.
    If the attribute does not exist, unselected parts are filled with zero values;
    otherwise, only the selected parts are filled.

Value
:   The input field to evaluate.

Name
:   The name to give the stored data.
user: Show practical ways to work with Shade Smooth in a Blender add-on or script – include code.

assistant: Sets an entire object as smooth or faceted.
This forces the assignment of the “smoothing” attribute to each face in the mesh,
including when you add or delete geometry.

This operator will also remove any [Smooth By Angle Modifiers](../../../modeling/modifiers/normals/smooth_by_angle.html).

Notice that the outline of the object is still strongly faceted.
Activating the smoothing features does not actually modify the object’s geometry;
it changes the way the shading is calculated across the surfaces (normals will be interpolated),
giving the illusion of a smooth surface.

Using [Shade Flat](#bpy-ops-object-shade-flat) will revert the shading back (normals will be constant)
to that shown in the first image below.

Example mesh flat (left) and smooth-shaded (right).
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:25-manual-meshsmooth-example.blend).

|  |  |
| --- | --- |
| <../../../_images/scene-layout_object_editing_shading_example-flat.png> | <../../../_images/scene-layout_object_editing_shading_example-smooth.png> |

Keep Sharp Edges
:   Do not clear sharp edges (which are redundant with objects shaded as flat).
    This option is useful to not destroy data in case you want to revert changes later.