PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Channels and how is it used in Blender Python scripting?

assistant: # Channels

A channel is a horizontal track that’s similar to a layer in an image editing program:
higher channels are displayed in front of lower ones.

Within each channel, you can create one or more
[strips](../../../video_editing/edit/montage/strips/introduction.xhtml), which contain either
a segment of video content (a rendered scene, an external video file…)
or an [effect](../../../video_editing/edit/montage/strips/effects/index.xhtml)
(color blending, blurring…). The X axis represents time, so the further a strip
is placed to the right, the later it will play in the final video.

While a channel can contain multiple strips, they can’t overlap each other.
If you want two strips to play at the same time, you need to place them in different channels.
user: Explain Glass and Transparent Shadows in complete detail according to the official Blender documentation.

assistant: With caustics disabled, glass shadows may appear too dark,
and with filter glossy the caustics might be too soft.
We can make a glass shader that will use a Glass BSDF when viewed *directly*,
and a Transparent BSDF when viewed *indirectly*. The Transparent BSDF can be used for
transparent shadows to find light sources straight through surfaces,
and will give properly-colored shadows, but without the caustics.
The Light Path node is used to determine when to use which of the two shaders.

[image reference removed]

Optimized glass shader.

Above we can see the node setup used for the glass transparency trick;
on the left the render has dark shadows due to missing caustics,
and on the right the render with the trick.

|  |  |
| --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_glass-too-much-shadow.jpg   Default Glass BSDF. | ../../../_images/render_cycles_optimizations_reducing-noise_glass-trick.jpg   Optimized Glass Shader. |
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`RenderEngine.begin_result`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.begin_result "bpy.types.RenderEngine.begin_result") - [`RenderEngine.end_result`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.end_result "bpy.types.RenderEngine.end_result") | - [`RenderEngine.get_result`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.get_result "bpy.types.RenderEngine.get_result") - [`RenderEngine.update_result`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.update_result "bpy.types.RenderEngine.update_result") |
user: Describe Duplicate from the Blender manual or Python API, including usage steps and snippets.

assistant: This operator duplicates the selected control points,
along with the curve segments implicitly selected (if any).
.. If only a handle is selected, the full point will be duplicated too.
The copy is selected so you can move it to another place.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Vertex Painting is a simple way of painting color onto an object, by directly
manipulating the color of vertices, rather than textures, and is fairly straightforward.
Vertex Painting stores the color information as a
[Color Attribute](../../modeling/meshes/properties/object_data.html#modeling-meshes-properties-object-data-color-attributes)
which can be used by different render engines.

Color attribute’s can be managed in the pallette pop-over in the middle of the header.

[image reference removed]

Vertex Painting Mode.

When a vertex is painted, the color of the vertex is modified according to
the settings of the brush. The color of all visible planes and edges attached to
the vertex are then modified with a gradient to the color of the other connected vertices.
Note that the color of occluded faces is not modified.
user: Show practical ways to work with Object Node in a Blender add-on or script – include code.

assistant: # Object Node

[[image reference removed]](../../../../_images/node-types_GeometryNodeInputObject.webp)

The *Object* input node outputs a single object. It can be connected to other object sockets
to make using the same object in multiple places more convenient.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Target Element
:   Faces:
    :   Calculate the closest point anywhere on the faces of the target’s mesh geometry.

    Edges:
    :   Calculate the closest point anywhere on the edges of the target’s mesh geometry.

    Points:
    :   Calculate the closest point or vertex on the target geometry. This mode is usually the fastest.
        This mode works for both point cloud and mesh geometry, the other modes only work for meshes.
user: What is Frequently Asked Questions and how is it used in Blender Python scripting?

assistant: ### Why is Blender unresponsive during rendering?

On older GPU generations, graphics cards can only either render or draw the user interface.
This can make Blender unresponsive while it is rendering.
Heavy scenes can also make Blender unresponsive on newer GPUs,
when using a lot of memory or executing expensive shaders, however this is generally less of a problem.

The only complete solution for this is to use a dedicated GPU for rendering, and another for display.

### Why does a scene that renders on the CPU not render on the GPU?

There may be multiple causes,
but the most common one is that there is not enough memory on your graphics card.
Typically, the GPU can only use the amount of memory that is on the GPU
(see [Would multiple GPUs increase available memory?](#would-multiple-gpus-increase-available-memory) for more information).
This is usually much smaller than the amount of system memory the CPU can access.
With CUDA, OptiX, HIP and Metal devices, if the GPU memory is full Blender will automatically
try to use system memory. This has a performance impact, but will usually still result in a faster render
than using CPU rendering.

### Can multiple GPUs be used for rendering?

Yes, go to Preferences ‣ System ‣ Compute Device Panel, and configure it as you desire.

### Would multiple GPUs increase available memory?

Typically, no, each GPU can only access its own memory.

The exception is NVIDIA GPUs connected with NVLink, where multiple GPUs can share memory at a small performance cost.
This can be enabled with [Distributed Memory Across Devices](../../editors/preferences/system.xhtml#prefs-system-cycles-distributive-memory)
in the preferences.

### What renders faster?

This varies depending on the hardware used. Different technologies also have different compute times
depending on the scene tested. For the most up to date information on the performance of different devices,
browse the [Blender Open Data](https://opendata.blender.org/) resource.
user: Describe Point Info from the Blender manual or Python API, including usage steps and snippets.

assistant: # Point Info

Cycles Only

[image reference removed]

The *Point Info* node can be used in the material node tree for point cloud objects
and gives access to the data of individual points.
It can be useful to give some variation to a single material assigned a point cloud object.
user: Show practical ways to work with Delete in a Blender add-on or script – include code.

assistant: Removes the selected *Vertices* (control points) or *Segments* (lines) from the surface. In both cases,
the selection must consist of one or more complete rows or columns of the surface grid.

Vertices
:   Deletes the selected control points. The resulting gap is bridged with new grid lines so that the surface
    stays contiguous.

Segments
:   Deletes the lines and control points that lie between the outermost selected control points.
    The resulting gap is not bridged.

Dissolve Vertices
:   This feature only works for [Curves](../../curves/index.html).

[image reference removed]

Before and after deleting a row of control points.
user: Give a detailed overview of For Each Geometry Element Zone: syntax, arguments, return values, common patterns.

assistant: # For Each Geometry Element Zone

This zone type allows executing nodes for each element of a geometry. For example, the nodes can process
every face of a mesh, or every instance.

[image reference removed]

The *For Each Element* zone.

The zone is ideal for tasks that generate large or complex geometry for every element of an input geometry.
For example, generating a unique tree for every input curve, or a unique building on every input face.

The zone makes less sense for processing small amounts of geometry. In that case (for example each of a character’s
hairs separately) it will likely **always be slower** than working on fewer larger geometries. The additional
flexibility from processing each element separately comes at the cost that Blender can’t optimize the operation
as well. For node groups that need to handle lots of geometry elements, it’s recommended to design the node setup
so that iteration over tiny sub-geometries is not required.
user: How do I use FunctionNodeCombineMatrix(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

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

assistant: Surface Geometry
:   The surface geometry to which the hair curves are attached.
    This is typically the same mesh used during hair generation or interpolation.

Surface UV Map
:   The UV map on the surface mesh used to locate the curve attachment points.
    It allows retrieving the stored attachment coordinates for each curve.
user: What is Baking Physics Simulations and how is it used in Blender Python scripting?

assistant: # Baking Physics Simulations

[Baking](../glossary/index.xhtml#term-Baking) refers to the act of storing or caching the results of a calculation.
The result of a simulation is automatically cached to memory when the animation is played,
so that the next time it runs, it can be replayed more quickly by reading the results from the memory.

If you bake the simulation the cache is protected,
and you will be unable to change the simulation settings
until you clear the baked frames by clicking *Delete Bake*.

It is generally recommended to bake your physics simulations before rendering.
Aside from no longer needing to go through the time-consuming process of simulating again,
baking can help prevent potential glitches and ensure that the outcome of the simulation
remains exactly the same every time.
user: Show practical ways to work with Text Rendering in a Blender add-on or script – include code.

assistant: Anti-Aliasing
:   Enable interface text [Anti-Aliasing](../../glossary/index.xhtml#term-Anti-Aliasing).
    When disabled, texts are rendered using straight text rendering (filling only absolute pixels).

Subpixel Anti-Aliasing
:   Render text for optimal horizontal placement.

Hinting
:   Adjust [font hinting](https://en.wikipedia.org/wiki/Font_hinting),
    controls the spacing and crispness of text display.

Interface Font
:   Replacement for the default user interface font.

Mono-space Font
:   Replacement for the default mono-space interface font
    *(used in the Text editor and Python Console)*.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.annotation_data`](bpy.context.html#bpy.context.annotation_data "bpy.context.annotation_data") - [`bpy.context.gpencil`](bpy.context.html#bpy.context.gpencil "bpy.context.gpencil") - [`bpy.context.grease_pencil`](bpy.context.html#bpy.context.grease_pencil "bpy.context.grease_pencil") | - [`BlendData.grease_pencils`](bpy.types.BlendData.html#bpy.types.BlendData.grease_pencils "bpy.types.BlendData.grease_pencils") - [`BlendDataGreasePencilsV3.new`](bpy.types.BlendDataGreasePencilsV3.html#bpy.types.BlendDataGreasePencilsV3.new "bpy.types.BlendDataGreasePencilsV3.new") - [`BlendDataGreasePencilsV3.remove`](bpy.types.BlendDataGreasePencilsV3.html#bpy.types.BlendDataGreasePencilsV3.remove "bpy.types.BlendDataGreasePencilsV3.remove") |
user: Give a detailed overview of Creating Faces: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Quad from an Edge with source automatically rotated.

If you have two vertices selected and already connected with an edge, `Ctrl`-`RMB` click
will create a planar face, also known as a quad. Blender will follow your mouse cursor
and will use the planar view from your viewport to create those quads.

For `Ctrl`-`RMB`, Blender will automatically rotate the last selected Edge (the source)
for the subsequent operations if you have at least one face created, dividing the angles created between
the newly created edge and the last two edges, creating a smooth angle between them. Blender will calculate
this angle using the last positive and negative position of the last X and Y coordinates
and the last connected unselected edge. If this angle exceeds a negative limit (following a quadrant rule)
between the recently created edge and the last two, Blender will wrap the faces.
But if you do not want Blender to rotate and smooth edges automatically when extruding from `Ctrl`-`RMB`,
you can also inhibit Blender from rotating sources using the shortcut `Shift`-`Ctrl`-`RMB`.
In this case, Blender will not rotate the source dividing the angle between those edges when creating a face.

If you have three or more vertices selected, and `Ctrl`-`RMB` click,
you will also create planar faces, but along the vertices selected, following the direction of the cursor.
This operation is similar to an extrude operation.
user: Describe Set Pivot from the Blender manual or Python API, including usage steps and snippets.

assistant: Like Object and Edit Mode, Sculpt Mode also has a [Pivot Point](../../../glossary/index.xhtml#term-Pivot-Point).
This is because the basic [move, rotate and scale](../tools/transforms.xhtml)
transforms are also supported in Sculpt Mode.
But the pivot point in Sculpt Mode is unique. It always moves together with the transformed mesh
and can be both manually & automatically placed.

Origin
:   Sets the pivot to the origin of the sculpt.

Unmasked
:   Sets the pivot position to the average position of the unmasked vertices.

Mask Border
:   Sets the pivot position to the center of the mask’s border.
    This operation will automatically happen when using [Expand](expand.xhtml#bpy-ops-sculpt-expand).

Active Vertex
:   Sets the pivot position to the active vertex position.

Surface `Shift`-`RMB`
:   Sets the pivot position to the surface under the cursor.
user: Describe PaletteColors(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # PaletteColors(bpy_struct)

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

*class* bpy.types.PaletteColors(*bpy_struct*)
:   Collection of palette colors

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

    new()
    :   Add a new color to the palette

        Returns:
        :   The newly created color

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

    remove(*color*)
    :   Remove a color from the palette

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

    clear()
    :   Remove all colors from the palette

    *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 Advect Grid Node, preserving all code examples.

assistant: # Advect Grid Node

[image reference removed]

The *Advect Grid* node moves voxel values through a velocity field over time
using numerical integration. This operation is called *advection* and is
commonly used in fluid, smoke, and motion simulation systems to evolve
quantities such as density, temperature, or color according to a flow field.

The node supports multiple integration schemes that trade off between speed,
accuracy, and numerical stability. It can be used for both scalar and vector
grids, provided the voxel size is uniform across the domain.

Advection is conceptually equivalent to tracing each voxel backward through the
velocity field by a small time step, sampling the grid value from the previous
location, and assigning that value to the current voxel.
user: Describe NodeGroupOutput(NodeInternal) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeGroupOutput(NodeInternal)

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")

*class* bpy.types.NodeGroupOutput(*NodeInternal*)
:   Output data from inside of a node group

    is_active_output
    :   True if this node is used as the active group output

        Type:
        :   boolean, default False

    *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 GeometryNodeIsViewport(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeIsViewport(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.GeometryNodeIsViewport(*GeometryNode*)
:   Retrieve whether the nodes are being evaluated for the viewport rather than the final render

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The `server-generate` command can optionally create a simple website using the `--html` argument.

```
blender --command extension server-generate --repo-dir=/path/to/packages --html
```

This creates an `index.html` file ready to use, listing extensions which
can be dropped into Blender for installation.

### Download Links

In order to support drag and drop for installing from a remote repository,
there are a few optional ways to prepare the URLs.

The only strict requirement is that the download URL must end in `.zip`.

You can pass different arguments to the URL to give more clues to Blender about what to do with the dropped URL.

> repository:
> :   Link to the JSON file to be used to install the repository in Blender.
>     Supports relative URLs.
>
> platforms:
> :   Comma-separated list of supported platforms.
>     If omitted, the extension will be available in all operating systems.
>
> blender_version_min:
> :   Minimum supported Blender version, e.g., `4.2.0`.
>
> blender_version_max:
> :   Blender version that the extension does not support, earlier versions are supported.

With the exception of the `repository`, all the other parameters can be extracted from the extensions manifest.
Those arguments are to be encoded as part of the URL.

Expected format:
:   `{URL}.zip?repository={repository}&blender_version_min={version_min}&blender_max={version_max_exclusive}&platforms={platform1,platform2}`

Example from self-hosted repository:
:   `http://my-site.com/my-addon.zip?repository=.%2Findex.json&blender_version_min=4.2.0&platforms=windows-x64`

Example from the Extensions Platform:
:   `https://extensions.blender.org/download/sha256:57a6a5f39fa2cc834dc086a27b7b2e572c12fd14f8377fb8bd1c7022df3d7ccb/add-on-amaranth-v1.0.23.zip?repository=%2Fapi%2Fv1%2Fextensions%2F&blender_version_min=4.2.0&platforms=linux-x64%2Cmacos-x64`
user: Describe Mesh Primitives from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mesh Primitives

Meshes are the most common object type used in 3D scenes.
Blender provides a variety of built-in mesh primitives that serve as starting points for modeling.
These primitives can be added in both Object Mode and Edit Mode, where they appear at the location of the 3D Cursor.

[image reference removed]

Blender’s standard mesh primitives.
user: Show practical ways to work with Simplify in a Blender add-on or script – include code.

assistant: # Simplify

Common Settings

Max Subdivision
:   Maximum number of subdivision by the Subdivision Surface modifiers.

Child Particles
:   Show only a subset of all child hairs and particles.

Texture Limit
:   Automatically scales textures down so that they are no larger than the values chosen.
    This can help reduce computer memory resources when rendering large scenes with huge textures.
user: Explain GeometryNodeDistributePointsInVolume(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeDistributePointsInVolume(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.GeometryNodeDistributePointsInVolume(*GeometryNode*)
:   Generate points inside a volume

    *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 Shortest Edge Paths Node and how is it used in Blender Python scripting?

assistant: # Shortest Edge Paths Node

[image reference removed]

The *Shortest Edge Paths* node finds paths along mesh edges to a selection of end vertices.
The cost used to define “shortest” can be set to anything. By default there is a constant cost
for every edge, but a typical input would be the length of each edge.

The output is encoded with vertex indices, and is meant to be used on the vertex domain.
For each vertex, the *Next Vertex Index* output gives the index of the following vertex
in the path to the “closest” endpoint.

The node is implemented with [Dijkstra’s algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).
user: Describe Before Reporting from the Blender manual or Python API, including usage steps and snippets.

assistant: Before reporting a bug, some basic steps should be taken to ensure that you are reporting a real issue.

- Ensure you have installed Blender according to the guidance in this manual under
  [Installing Blender](../getting_started/installing/index.html).
- Follow the steps in this Troubleshooting section first, starting with loading factory settings. Many crashes and
  errors may be caused by bad settings or add-ons that have not been updated to work with the newest release of
  Blender.
user: Provide the full official documentation entry for NodeSocketFloat(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketFloat(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.NodeSocketFloat(*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: Describe Bone Roll from the Blender manual or Python API, including usage steps and snippets.

assistant: # Bone Roll

The bone roll is a part of a bone’s [rest pose](../../../../glossary/index.xhtml#term-Rest-Pose) defining its default rotation around the bone’s length.
You can control the bone roll in *Edit Mode*.
user: Provide the full official documentation entry for Brush, preserving all code examples.

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: Describe NodeInstanceHash(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeInstanceHash(bpy_struct)

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

*class* bpy.types.NodeInstanceHash(*bpy_struct*)
:   Hash table containing node instance data

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

assistant: # ThemeSpaceGeneric(bpy_struct)

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

*class* bpy.types.ThemeSpaceGeneric(*bpy_struct*)
:   back
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    header
    :   Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 0.0)

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

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

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

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

    title
    :   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
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Brush.mask_texture_slot`](bpy.types.Brush.html#bpy.types.Brush.mask_texture_slot "bpy.types.Brush.mask_texture_slot") | - [`Brush.texture_slot`](bpy.types.Brush.html#bpy.types.Brush.texture_slot "bpy.types.Brush.texture_slot") |
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Tone Compositor Only
:   Standard:
    :   The Combined curve is applied to each channel individually, which may result in a change of hue.

    Filmlike:
    :   Keeps the hue constant.

Channel
:   The curve to show.

    C:
    :   Combined

    R:
    :   Red

    G:
    :   Green

    B:
    :   Blue

Curve
:   A Bézier curve that maps each input level (X axis) to an output level (Y axis).
    For the curve controls, see [Curve widget](../../../../interface/controls/templates/curve.xhtml#ui-curve-widget).
user: Explain Tool Settings in complete detail according to the official Blender documentation.

assistant: Layer
:   Restrict interpolation to either the *Active Layer* or *All Layers*.

Only Selected (Edit Mode)
:   When enabled, only selected strokes will be interpolated.

Exclude Breakdowns
:   Exclude existing [Breakdown keyframes](../../../../animation/keyframes/introduction.html#keyframe-type) from being used as interpolation extremes.

Flip Mode
:   Reverses the interpolation direction, swapping the start and end strokes.
    *Automatic* mode attempts to determine the correct direction for each stroke automatically.

Smooth
:   The amount of smoothing applied to interpolated strokes to reduce jitter or visual noise.

Iterations
:   The number of times smoothing is applied to newly created strokes.
    Higher values result in smoother interpolation but may reduce shape fidelity.
user: What is Limit Total and how is it used in Blender Python scripting?

assistant: Reduce the number of weight groups per vertex to the specified Limit.
The tool removes lowest weights first until the limit is reached.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   Maximum number of weights allowed on each vertex.
user: How do I use CacheFileLayers(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CacheFileLayers(bpy_struct)

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

*class* bpy.types.CacheFileLayers(*bpy_struct*)
:   Collection of cache layers

    active
    :   Active layer of the CacheFile

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

    new(*filepath*)
    :   Add a new layer

        Parameters:
        :   **filepath** (*string**,* *(**never None**)*) – File path to the archive used as a layer

        Returns:
        :   Newly created layer

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

    remove(*layer*)
    :   Remove an existing layer from the cache file

        Parameters:
        :   **layer** ([`CacheFileLayer`](bpy.types.CacheFileLayer.html#bpy.types.CacheFileLayer "bpy.types.CacheFileLayer"), (never None)) – Layer to remove

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

assistant: Geometry
:   The resulting geometry with braided deformation applied.

Flare Parameter
:   A value from 0 to 1 indicating the position along the braid flare region.
    This can be used for shading or for adding effects (such as tying, binding, or loosening
    near the braid tip).

Strand Index
:   An index identifying which strand of the braid each curve belongs to within its braid group.

### Guide Map

Guide Index
:   The guide index map actually used to generate the braid.
    If a new guide map was created by this node, it is provided here for reuse downstream.
user: Describe Sequencer Scene from the Blender manual or Python API, including usage steps and snippets.

assistant: # Sequencer Scene

The video sequencer uses a separate scene data-block that contains the edit. This is the *Sequencer Scene*.

Having a separated scene for the video sequencer has multiple benefits, like managing different
versions of an edit within the same file. Another important use-case is working with
different scenes in the file and scene strips. See the section below about working with multiple scenes
and scene strips.
user: How do I use NodeSocketVectorPercentage4D(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketVectorPercentage4D(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.NodeSocketVectorPercentage4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 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: Provide the full official documentation entry for Window Cursor Items, preserving all code examples.

assistant: # Window Cursor Items

DEFAULT:
:   Default.

NONE:
:   None.

WAIT:
:   Wait.

CROSSHAIR:
:   Crosshair.

MOVE_X:
:   Move-X.

MOVE_Y:
:   Move-Y.

KNIFE:
:   Knife.

TEXT:
:   Text.

PAINT_BRUSH:
:   Paint Brush.

PAINT_CROSS:
:   Paint Cross.

DOT:
:   Dot Cursor.

ERASER:
:   Eraser.

HAND:
:   Open Hand.

HAND_POINT:
:   Pointing Hand.

HAND_CLOSED:
:   Closed Hand.

SCROLL_X:
:   Scroll-X.

SCROLL_Y:
:   Scroll-Y.

SCROLL_XY:
:   Scroll-XY.

EYEDROPPER:
:   Eyedropper.

PICK_AREA:
:   Pick Area.

STOP:
:   Stop.

COPY:
:   Copy.

CROSS:
:   Cross.

MUTE:
:   Mute.

ZOOM_IN:
:   Zoom In.

ZOOM_OUT:
:   Zoom Out.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Output
:   Outputs the value from the input corresponding to the selected menu item, unchanged.

For each menu entry, an additional Boolean output is created.
The output corresponding to the selected item is *true*, and all others are *false*.
These Boolean outputs can be used to trigger different node branches, control visibility,
or drive conditional operations elsewhere in the node tree.
user: How do I use Sequencer & Preview in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sequencer & Preview

This view type shows both the preview and the sequencer inside one editor.

[image reference removed]

Figure 1: Combined Sequencer & Preview

In general, it’s better to avoid this view type and instead have two editors,
one serving as the *Preview* and the other as the *Sequencer*.
Reasons for this include:

- Most of the *Preview* tools, such as Move and Rotate, are not available
  in *Sequencer & Preview*.
- You can’t add a small editor (such as a File Browser) on the side that only
  takes up the height of the preview.
- You can’t maximize the preview on another screen.

One way of getting two separate editors is to simply open the default
*Video Editing* [workspace](../../interface/window_system/workspaces.xhtml).
(You may need to click the “+” icon to the right of the tabs to find it.)
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`BevelModifier.custom_profile`](bpy.types.BevelModifier.html#bpy.types.BevelModifier.custom_profile "bpy.types.BevelModifier.custom_profile") - [`Curve.bevel_profile`](bpy.types.Curve.html#bpy.types.Curve.bevel_profile "bpy.types.Curve.bevel_profile") | - [`ToolSettings.custom_bevel_profile_preset`](bpy.types.ToolSettings.html#bpy.types.ToolSettings.custom_bevel_profile_preset "bpy.types.ToolSettings.custom_bevel_profile_preset") |
user: Show practical ways to work with Depth Combine Node in a Blender add-on or script – include code.

assistant: # Depth Combine Node

[image reference removed]

The Depth Combine node combines two images based on their depth maps.
It overlays the images using the provided depth values to
detect which parts of one image are in front of the other.
user: How do I use Edge Angle Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Edge Angle Node

[image reference removed]

The *Edge Angle* node calculates the angle in radians between two faces that meet at an edge.
For the Face, Face Corner, and Point [domains](../../attributes_reference.html#attribute-domains),
the node uses simple domain interpolation to move values from the mesh’s edges.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Color 1/2
:   Color of the bricks.

Mortar
:   The color of the area between bricks.

Scale
:   Overall texture scale.

Mortar Size
:   The size of the filling between the bricks known as “mortar”; 0 means no mortar.

Mortar Smooth
:   Blurs/softens the edge between the mortar and the bricks.
    This can be useful with a texture and displacement textures.

Bias
:   The color variation between *Color 1/2*.
    Values of -1 and 1 only use one of the two colors; values in between mix the colors.

Brick Width
:   The ratio of brick’s width relative to the texture scale.

Row Height
:   The ratio of brick’s row height relative to the texture scale.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`Mask.layers`](bpy.types.Mask.html#bpy.types.Mask.layers "bpy.types.Mask.layers") - [`MaskLayers.active`](bpy.types.MaskLayers.html#bpy.types.MaskLayers.active "bpy.types.MaskLayers.active") | - [`MaskLayers.new`](bpy.types.MaskLayers.html#bpy.types.MaskLayers.new "bpy.types.MaskLayers.new") - [`MaskLayers.remove`](bpy.types.MaskLayers.html#bpy.types.MaskLayers.remove "bpy.types.MaskLayers.remove") |
user: How do I use Recovering The Last Session in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Recover Last Session* will open the `quit.blend` file that is saved into the [Temporary Directory](../advanced/blender_directory_layout.xhtml#temp-dir) when you quit
Blender under normal operation (see [Blender Session](../glossary/index.xhtml#term-Blender-Session)). Note that files in your temporary directory may be
deleted when you reboot your computer (depending on your system configuration) or by scheduled disk cleanup tools or
scripts.
user: Describe Growing from the Blender manual or Python API, including usage steps and snippets.

assistant: The first step is to create the hair, specifying the amount of hair strands and their lengths.

The complete path of the particles is calculated in advance.
So everything a particle does a hair may do also.
A hair is as long as the particle path would be for a particle with a lifetime of 100 frames.
Instead of rendering every frame of the particle animation point by point there are calculated
control points with an interpolation, the segments.
user: Give a detailed overview of Hints: syntax, arguments, return values, common patterns.

assistant: ### Offset Calculation

The transformation applied from one copy to the next is calculated as the sum of the three
different components (*Relative*, *Constant* and *Object*),
each of which can be enabled/disabled independently of the others. This allows, for example,
a relative offset of (1.0, 0.0, 0.0) and a constant offset of (0.1, 0.0, 0.0),
giving an array of objects neatly spaced along the X axis with a constant 0.1
unit between them, whatever the original object’s size.
user: Show practical ways to work with Stucci in a Blender add-on or script – include code.

assistant: # Stucci

[image reference removed]

Stucci Texture panels.

The *Stucci* texture is based on noise functions. It is often used for stone, asphalt, or oranges,
normally for bump mapping to create grainy surfaces.