PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Volume
:   The resulting volume geometry containing the newly stored grid.
    If a grid with the same name previously existed, it is replaced with the
    new one; otherwise, the grid is added as a new entry.
user: What is Examples and how is it used in Blender Python scripting?

assistant: ### Creating an Alpha Mask

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

[[image reference removed]](../../../_images/compositing_types_converter_color-ramp_create-alpha-mask.png)

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

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

### Colorizing an Image

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

[[image reference removed]](../../../_images/compositing_types_converter_color-ramp_colorizing-image.png)

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.
user: Provide the full official documentation entry for Views, preserving all code examples.

assistant: In Tracking Mode there are three different views available. You can toggle between view modes using
the View selector, which is located in the header.
When you selected a view in the whole area of the Movie Clip editor will change.
Hence, to display a curve or dope sheet view, the editor must be split into two,
with one switched to the curve or dope sheet view.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Vector Type
:   The node applies the transformation differently depending on the semantic type of the input vector.

    Point:
    :   For this vector type, the node performs a straightforward transformation.

        Transforming a texture coordinates is analogous to transforming a UV map.
        For instance, translating the texture coordinates along the **positive** X axis would result
        in the evaluated texture to move in the **negative** X axis, much like if one translated a UV map.
        Similarly, scaling the texture coordinates **up** would result in the evaluated texture to scale **down**.
        So transforming the texture coordinates would appear to have the opposite effect on the evaluated texture.

        The order of transformation is: Scale –> Rotate –> Translate, which means:

        - Translation moves the input along the local rotation axis.
        - Rotation rotates the input around the origin of the space.
        - Scaling scales the input along the global axis.

    Texture:
    :   For this vector type, the node performs an inverse transformation.

        Inverse transforming a texture coordinates would, as opposed to the *Point* type,
        transform the evaluated texture itself. For instance, translating the texture coordinates along
        the positive X axis would result in the evaluated texture to move in the positive X axis,
        as one would expected. Similarly, scaling the texture coordinates up would result in
        the evaluated texture to scale up, as one would expect.

        The order of transformation is: Translate –> Rotate –> Scale, which means:

        - Translation moves the input along the global axis.
        - Rotation rotates the input around the translation vector.
        - Scaling scales the input along the local rotation axis.

    Vector:
    :   For this vector type, a *Point* transformation is performed, but with zero translation.

    Normal:
    :   For this vector type, the node performs the inverse transpose of the transformation and normalize the result.
        Such transformation ensures correct normals after non-uniform scaling.
        So this type should be used when transforming normals.
user: How do I use MovieTrackingReconstructedCameras(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MovieTrackingReconstructedCameras(bpy_struct)

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

*class* bpy.types.MovieTrackingReconstructedCameras(*bpy_struct*)
:   Collection of solved cameras

    find_frame(*\**, *frame=1*)
    :   Find a reconstructed camera for a give frame number

        Parameters:
        :   **frame** (*int in* *[**0**,* *1048574**]**,* *(**optional**)*) – Frame, Frame number to find camera for

        Returns:
        :   Camera for a given frame

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

    matrix_from_frame(*\**, *frame=1*)
    :   Return interpolated camera matrix for a given frame

        Parameters:
        :   **frame** (*int in* *[**0**,* *1048574**]**,* *(**optional**)*) – Frame, Frame number to find camera for

        Returns:
        :   Matrix, Interpolated camera matrix for a given frame

        Return type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 items in [-inf, inf]

    *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 Grease Pencil Materials in complete detail according to the official Blender documentation.

assistant: # Grease Pencil Materials

Materials control the appearance of the Grease Pencil object.
They define the base color and texture of the strokes and filled areas.

There is always only one active material in the list (the selected one).
When you draw, the new strokes use the active material.

You can override the base material color using the tools in
[Vertex Mode](../modes/vertex_paint/introduction.xhtml)
or the Draw and Tint tool in Draw Mode.

The material always remains linked to the strokes, this means that any change in a material will change
the look of already drawn strokes.

[image reference removed]

Same stroke linked to different materials.
user: Provide the full official documentation entry for FunctionNodeMatrixMultiply(FunctionNode), preserving all code examples.

assistant: # FunctionNodeMatrixMultiply(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.FunctionNodeMatrixMultiply(*FunctionNode*)
:   Perform a matrix multiplication on two input matrices

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

assistant: Mesh
:   Mesh component of the input geometry.

Curve
:   Curve component of the input geometry.

Point Cloud
:   Point cloud component of the input geometry.

Volume
:   Volume component of the input geometry.

Instances
:   Instances component of the input geometry. Even if the instances contain geometry data with
    one of the other types, all instances will be added to this output.
    A [Realize Instances Node](../../instances/realize_instances.xhtml) can be added to move the data from
    geometry instances to their corresponding outputs.
user: Describe Execution Context from the Blender manual or Python API, including usage steps and snippets.

assistant: When calling an operator you may want to pass the execution context.

This determines the context that is given for the operator to run in, and whether
invoke() is called or only execute().

`EXEC_DEFAULT` is used by default, running only the `execute()` method, but you may
want the operator to take user interaction with `INVOKE_DEFAULT` which will also
call invoke() if existing.

The execution context is one of:

- `INVOKE_DEFAULT`
- `INVOKE_REGION_WIN`
- `INVOKE_REGION_CHANNELS`
- `INVOKE_REGION_PREVIEW`
- `INVOKE_AREA`
- `INVOKE_SCREEN`
- `EXEC_DEFAULT`
- `EXEC_REGION_WIN`
- `EXEC_REGION_CHANNELS`
- `EXEC_REGION_PREVIEW`
- `EXEC_AREA`
- `EXEC_SCREEN`

```
# Collection add popup.
import bpy
bpy.ops.object.collection_instance_add('INVOKE_DEFAULT')
```

It is also possible to run an operator in a particular part of the user
interface. For this we need to pass the window, area and sometimes a region.

```
# Maximize 3d view in all windows.
import bpy
from bpy import context

for window in context.window_manager.windows:
    screen = window.screen
    for area in screen.areas:
        if area.type == 'VIEW_3D':
            with context.temp_override(window=window, area=area):
                bpy.ops.screen.screen_full_area()
            break
```
user: Show practical ways to work with Color Picker in a Blender add-on or script – include code.

assistant: # Color Picker

[image reference removed]

Circle HSV color picker.

The *Color Picker* is a pop-up control that allows you to define and adjust color values.
It appears when editing any color property in Blender, such as materials, lights, brushes, or interface themes.

The color picker provides multiple color models and interaction modes to suit different workflows,
and can display or edit colors in both *linear* and *perceptual* (display-referred) color spaces.
user: How do I use Simulation in Blender? Include parameters, examples, warnings and best practices.

assistant: Simulation Range
:   Use a simulation range that is different from the scene range for
    [Simulation Nodes](../../modeling/geometry_nodes/simulation/simulation_zone.xhtml)
    that do not override the frame range themselves.

Start, End
:   The frame at which the simulation starts/ends.
user: Show practical ways to work with CompositorNodeCurveRGB(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeCurveRGB(CompositorNode)

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"), [`CompositorNode`](bpy.types.CompositorNode.html#bpy.types.CompositorNode "bpy.types.CompositorNode")

*class* bpy.types.CompositorNodeCurveRGB(*CompositorNode*)
:   Perform level adjustments on each color channel of an image

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

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

    update()

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

assistant: Image
:   Standard color input.

Type
:   Undistort:
    :   Used to undistort the image received, and is usually used for the raw distorted movie clip.

    Distort:
    :   Used to distort the image received, and is usually used for rendered images.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The Sequencer view is where most of the video editing happens.
It shows a stack of [channels](channels.xhtml),
in which you can create [strips](../../../video_editing/edit/montage/strips/introduction.xhtml).
user: Show practical ways to work with Bind Camera to Markers in a Blender add-on or script – include code.

assistant: *Bind Camera to Markers* allows markers to be used to set the active object as the active camera.

To use this operator, select the object to become the active camera
and select a marker to bind the active camera to.
If no marker is selected when the operator is applied, a marker will be added.
When an object is bound to a marker, the marker will be renamed to the name of the active object.
These markers also have a camera icon next to the left of the name
to easily distinguish them from other informative markers.

These markers can be moved to change the frame at which
the active camera is changed to the object the marker is bound to.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Domain
:   The domain on which the selection field is evaluated.

    Point:
    :   The selection is on the points, control points, and vertices of the geometry.

    Edge:
    :   The selection is on the edges of the mesh component. The other components
        are not modified.

    Faces:
    :   The selection is on the faces of the mesh component. The other components
        are not modified.

    Spline:
    :   The selection is on the splines in the curve component. For each spline, it
        is either entirely in the selection or not at all. The other components are not
        modified.
user: Show practical ways to work with History in a Blender add-on or script – include code.

assistant: [Laplacian Surface Editing](https://igl.ethz.ch/projects/Laplacian-mesh-processing/Laplacian-mesh-editing/laplacian-mesh-editing.pdf)
is a method developed by Olga Sorkine and others in 2004.
This method preserves geometric details as much as possible while the user makes editing operations.
This method uses [differential coordinates](https://igl.ethz.ch/projects/Laplacian-mesh-processing/Laplacian-mesh-editing/diffcoords-editing.pdf)
corresponding to the difference between a vector and the weighted average
of its neighbors to represent the local geometric detail of the mesh.

[image reference removed]

Differential Coordinate.
user: How do I use Online Editing in Blender? Include parameters, examples, warnings and best practices.

assistant: # Online Editing

Welcome!
This page explains the process for contributing to Blender’s documentation through our online editing workflow.
Whether you’re fixing typos or adding entirely new sections, your contributions are valuable.

Below is an overview of the online editing process.
user: Provide the full official documentation entry for Further Options, preserving all code examples.

assistant: R, G, B
:   Tracking happens in gray-scale space, so a high contrast between the feature and
    its background yields more accurate tracking.
    In such cases disabling some color channels can help.

Grayscale Preview (B/W)
:   Display the preview image as gray-scale even if all channels are enabled.

Alpha
:   Applies mask defined by an annotation tool in the preview widget.

Weight
:   When several tracks are used for 3D camera reconstruction, it is possible to assign
    a reduced weight to some tracks to control their influence on the solution result.
    This parameter can (and often need to) be animated.

    Altering the weights of problem tracking markers can correct or greatly reduce undesirable jumps
    as feature disappear or become difficult to track.

    Another use of Track Weights is when you want to reconstruct a scene from your camera solution.
    In that case you can first carefully track and solve your scene, and once you are done,
    lock all your markers with `Ctrl`-`L`, set the tracker weight in the Extra Settings of
    the tracker settings to zero and use the feature detection to quickly add lots of markers.
    Now track them and solve the scene again. Since their weight is zero
    they will not influence your solution at all, but you will have lots of good reference points in your scene.

Stabilization Weight
:   While *Weight* parameter is used for 3D reconstruction,
    the *Stabilization Weight* is used to control 2D stabilization.

Custom Color Presets
:   The preset for the *Custom Color*.

Custom Color
:   This setting overrides the default marker color used in the Clip editor and 3D Viewport,
    and it helps to distinguish different type of features
    (for example, features in the background vs. foreground and so on).
    Color also can be used for “grouping” tracks so a whole group of tracks can be selected by
    color using the Select Grouped operator.
user: How do I use Sound to Samples in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates a sampled curve based on a sound file. Use *Samples to Keys* if you need to edit it.

Lowest Frequency
:   Cutoff frequency of a high-pass filter that is applied to the audio data.

Highest Frequency
:   Cutoff frequency of a low-pass filter that is applied to the audio data.

Attack Time
:   Value for the hull curve calculation that tells how fast the hull curve can rise.
    The lower the value, the steeper it can rise.

Release Time
:   Value for the hull curve calculation that tells how fast the hull curve can fall.
    The lower the value, the steeper it can fall.

Threshold
:   Minimum amplitude value needed to influence the hull curve.

Accumulate
:   Only the positive differences of the hull curve amplitudes are summarized to produce the output.

Additive
:   The amplitudes of the hull curve are summarized. If *Accumulate* is enabled,
    both positive and negative differences are accumulated.

Square
:   Gives the output as a square curve.
    Negative values always result in -1, and positive ones in 1.

    Square Threshold
    :   All values lower than this threshold result in 0.
user: Describe Development from the Blender manual or Python API, including usage steps and snippets.

assistant: Being open source, Blender welcomes development from volunteers. Communication between developers is done mostly
through three platforms:

- The [projects.blender.org](https://projects.blender.org/) system
- [Developer Forum](https://devtalk.blender.org/)
- Online Chat (see below)

If you are interested in helping develop Blender, see the [Get Involved](https://www.blender.org/get-involved/)
page.
user: How do I use Sample Nearest Surface Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sample Nearest Surface Node

[image reference removed]

The *Sample Nearest Surface* node finds values at the closest points on
the surface of a source mesh geometry. Non-face attributes are interpolated
across the surface.

This node is similar to the [Geometry Proximity Node](../../geometry/sample/geometry_proximity.html),
but it gives the value of any attribute at the closest surface point, not just its position.
user: What is Curve Info and how is it used in Blender Python scripting?

assistant: # Curve Info

The *Curve Info* node provides per-curve attributes describing the identity,
geometry, and relationships of each curve in a hair or curve system.
It is often used in procedural grooming and deformation setups to drive
randomization, orientation, or effects that depend on each curve’s properties.
user: How do I use Attributes in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Attributes* panel displays the available data fields associated with each point in the point cloud.
These attributes define characteristics like point position, size, color, and motion.

Use the [List View](../../interface/controls/templates/list_view.html#ui-list-view) interface to browse, create, edit, or remove attributes.

### Attribute Types

The following are common built-in attributes supported by point cloud objects:

| Name | Type | Domain | Description |
| --- | --- | --- | --- |
| `position` | *Vector* | *Point* | Stores the 3D coordinates of each point in the object’s local space. |
| `radius` | *Float* | *Point* | Defines the visual radius (size) of each point when rendered or displayed. |
| `color` | *Color* | *Point* | The display color of the point. Used in viewport rendering or shading. |
| `id` | *Integer* | *Point* | A unique identifier assigned to each point. Useful for persistent referencing. |
| `velocity` | *Vector* | *Point* | Indicates the directional movement and speed of the point (e.g., for simulations or motion blur). |

Custom Attributes
:   Custom attribute can be given to particles to hold a custom characteristic.

    Name
    :   The name of the attribute.

    Data Type
    :   The type of data to store in the attribute.

        Float:
        :   Floating-point value

        Integer:
        :   32-bit integer

        Vector:
        :   3D vector with floating-point values

        Color:
        :   RGBA color with floating-point precision

        Byte Color:
        :   RGBA color with 8-bit precision

        String:
        :   Text string

    Domain
    :   The type of element the attribute is stored in.
        Currently, attributes can only be stored per *Point*.
user: Provide the full official documentation entry for ChannelDriverVariables(bpy_struct), preserving all code examples.

assistant: # ChannelDriverVariables(bpy_struct)

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

*class* bpy.types.ChannelDriverVariables(*bpy_struct*)
:   Collection of channel driver Variables

    new()
    :   Add a new variable for the driver

        Returns:
        :   Newly created Driver Variable

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

    remove(*variable*)
    :   Remove an existing variable from the driver

        Parameters:
        :   **variable** ([`DriverVariable`](bpy.types.DriverVariable.html#bpy.types.DriverVariable "bpy.types.DriverVariable"), (never None)) – Variable to remove from the driver

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

assistant: # Cache

The *Cache* panel is used to [Bake](../../../../glossary/index.html#term-Baking) the fluid simulation and stores the outcome of
a simulation so it does not need to be recalculated.

Baking takes a **lot** of compute power (hence time). Depending on the scene, it is recommended
to allocate enough time for the baking process.

If the mesh has modifiers, the rendering settings are used for exporting the mesh to the fluid solver.
Depending on the setting, calculation times and memory use might exponentially increase. For example,
when using a moving mesh with *Subdivision Surface* as an obstacle, it might help to decrease simulation
time by switching it off, or to a low subdivision level. When the setup/rig is correct, you can always
increase settings to yield a more realistic result.

Cache Directory
:   Directory to store baked simulation files in. Inside this directory each simulation type
    (i.e. mesh, particles, noise) will have its own directory containing the simulation data.

Frame Start
:   The simulation starts on this frame, and this is the first one that is baked.

End
:   The simulation ends on this frame, and this is the last one to be baked.

Offset
:   Frame offset that is used when loading the simulation from the cache.
    It is not considered when baking the simulation, only when loading it.

Type
:   The type of the cache determines how the cache can be baked.

    Replay:
    :   The cache will be baked as the simulation is being played in the viewport.

    Modular:
    :   The cache will be baked step by step: The bake operators for this type are spread across various panels within
        the domain settings (e.g. the bake tool for the mesh can be found in the Mesh panel).

    All:
    :   The cache will be baked with a single tool. All selected settings will be considered during this bake.
        The bake tool for this type can be found in the Cache panel.

Resumable
:   Extra data will be saved so that you can resumed baking after pausing. Since more data will be written
    to drive it is recommended to avoid enabling this option when baking at high resolutions.

Bake All, Free All
:   This option is only available when using the [Final](#bpy-types-fluiddomainsettings-cache-type) cache type.
    *Bake All* will run the simulation considering all parameters from
    the settings (i.e. it will bake all steps that can be baked individually with
    the [Modular](#bpy-types-fluiddomainsettings-cache-type) cache type at once).

    The progress will be displayed in the status bar. Pressing `Esc` will abort the simulation.

    Once the simulation has been baked, the cache can be deleted by pressing *Free All*.
    It is not possible to pause or resume a *Bake All* process as
    only the most essential cache files are stored on drive.
user: Explain 3D Viewport Keys in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| `MMB` | Orbit View |
| `Shift`-`MMB` | Pan View |
| `Ctrl`-`MMB` | Zoom View |
| `Tab` | Toggle Edit mode. |
| `Ctrl`-`Tab` | Toggle Pose mode for armatures, or show a [mode](../../editors/3dview/modes.xhtml) switching pie menu for others. |
| `1` - `3` | In Edit Mode, switch between editing vertices (`1`), edges (`2`), or faces (`3`).  Hold `Shift` to toggle one of these without disabling the others.  Hold `Ctrl` to alter how the selection is transformed from the old mode to the new.  See [Mesh Selection Modes](../../modeling/meshes/selecting/introduction.xhtml) for details. |
| `AccentGrave` | Show 3D Viewport navigation pie menu. |
| `Ctrl`-`AccentGrave` | Toggle gizmos. |
| `Shift`-`AccentGrave` | Start [Fly/Walk Navigation](../../editors/3dview/navigate/walk_fly.xhtml#dview-fly-walk). |
user: Show practical ways to work with ArmatureConstraint(Constraint) in a Blender add-on or script – include code.

assistant: # ArmatureConstraint(Constraint)

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

*class* bpy.types.ArmatureConstraint(*Constraint*)
:   Applies transformations done by the Armature modifier

    targets
    :   Target Bones

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

    use_bone_envelopes
    :   Multiply weights by envelope for all bones, instead of acting like Vertex Group based blending. The specified weights are still used, and only the listed bones are considered.

        Type:
        :   boolean, default False

    use_current_location
    :   Use the current bone location for envelopes and choosing B-Bone segments instead of rest position

        Type:
        :   boolean, default False

    use_deform_preserve_volume
    :   Deform rotation interpolation with quaternions

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Threads Mode
:   Method to determine the maximum number of CPU cores to use while rendering.

    Auto-Detect:
    :   Automatically chooses the amount of threads to match the number of logical processors on your computer.

    Fixed:
    :   Manually choose the maximum number threads to use for rendering.
        This can be useful for example, if you want to use your computer while rendering,
        you can set the property to a thread count lower the amount of logical processors on your computer.

Threads
:   The maximum number of CPU cores to use simultaneously while rendering.
user: How do I use Is Face Planar Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Is Face Planar Node

[image reference removed]

The *Is Face Planar* node outputs whether every triangle of a
[quads](../../../../glossary/index.html#term-Quad) or [N-gons](../../../../glossary/index.html#term-N-gon) is on the same plane as all of the others, in
other words, if they have the same [normal](../../../meshes/editing/mesh/normals.html).

For example, a non-planar face can be created by moving a single vertex in a face but not
the others. Triangles will always be planar.
user: What is T and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [Tags](advanced/extensions/tags.xhtml#index-0) - [**Tail**](glossary/index.xhtml#term-Tail) - [**Tangent**](glossary/index.xhtml#term-Tangent) - [**Tessellation**](glossary/index.xhtml#term-Tessellation) - [**Texture**](glossary/index.xhtml#term-Texture) - [**Texture Space**](glossary/index.xhtml#term-Texture-Space) - [**Timecode**](glossary/index.xhtml#term-Timecode) | - [**Title Safe**](glossary/index.xhtml#term-Title-Safe) - [**Topology**](glossary/index.xhtml#term-Topology) - [**Transform**](glossary/index.xhtml#term-Transform)   - [Modeling Transform](modeling/transform/introduction.xhtml#index-0) - [**Transformation**](glossary/index.xhtml#term-Transformation) - [**Transformation Matrix**](glossary/index.xhtml#term-Transformation-Matrix) - [**Triangle**](glossary/index.xhtml#term-Triangle) |
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`EffectStrip.proxy`](bpy.types.EffectStrip.html#bpy.types.EffectStrip.proxy "bpy.types.EffectStrip.proxy") - [`ImageStrip.proxy`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.proxy "bpy.types.ImageStrip.proxy") - [`MetaStrip.proxy`](bpy.types.MetaStrip.html#bpy.types.MetaStrip.proxy "bpy.types.MetaStrip.proxy") | - [`MovieStrip.proxy`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.proxy "bpy.types.MovieStrip.proxy") - [`SceneStrip.proxy`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.proxy "bpy.types.SceneStrip.proxy") |
user: How do I use Node Closures in Blender? Include parameters, examples, warnings and best practices.

assistant: # Node Closures

A *closure* allows passing custom functionality into a node group.
It acts like a function input, enabling user-defined behavior to be evaluated inside another node tree.

Closures make node groups more flexible and reusable by letting users inject part of a node network into another.
This allows building higher-level tools where specific parts of a process can be customized without modifying the
group itself.

[image reference removed]

Using a closure to customize tree scattering within a terrain generator.
user: What is UV Tangent Node and how is it used in Blender Python scripting?

assistant: # UV Tangent Node

[image reference removed]

The *UV Tangent* node generates tangent direction vectors based on a specified UV map.
Tangents are unit-length vectors that lie along the surface of the geometry
and point in the direction of increasing *U* coordinates in the UV space.
They are commonly used in shading and texturing workflows, for example in
normal mapping or anisotropic effects.

This node allows for either exact or approximate tangent computation, offering
a balance between precision and performance depending on the use case.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Volume to Mesh modifier.

Object
:   The source volume object.

Grid Name
:   The name of the grid that will be converted.
    This has to be a scalar grid.

Resolution Mode
:   Mode for how the resolution of the final mesh is controlled.

    Grid
    :   This makes the resolution dependent on the resolution of the grid that is converted.
        Higher resolution grids result in a higher resolution mesh.
        In many cases, that is the most efficient mode.

    Voxel Amount
    :   Specifies the approximate resolution of the final mesh.
        The voxel size is adapted to the size of the entire volume.

    Voxel Size
    :   Use a fixed resolution that does not change when the volume changes.

Threshold
:   Voxels with a larger value are considered to be inside the mesh and all other voxels outside.
    The mesh will be generated on the boundary of inside and outside voxels.
    This is sometimes also called the “iso value”.

Adaptivity
:   This is similar to decimating the final to reduce resolution where it is not needed.

Smooth Shading
:   Enables smooth shading on the generated mesh.
user: Show practical ways to work with Pixel Filter in a Blender add-on or script – include code.

assistant: Due to limited resolution of images and computer screens, pixel filters are needed to avoid [Aliasing](../../../glossary/index.xhtml#term-Aliasing).
This is achieved by slightly blurring the image to soften edges.

Type
:   Pixel Filtering algorithm to use.

    Box:
    :   No filter.

    Gaussian:
    :   Smooth filter.

    Blackman-Harris:
    :   Default filter with a better balance between smoothness and detail preservation.

Width
:   Lower values give more crisp renders, higher values are softer and reduce aliasing.
user: Provide the full official documentation entry for Storyboarding App Template, preserving all code examples.

assistant: # Storyboarding App Template

The *Storyboarding* app template provides a ready-to-use setup for creating storyboards
in Blender, combining 2D drawing and scene management tools in one workspace.

It is based on the *2D Animation* template, but adds a configured Video Sequence Editor (VSE)
for organizing shots using the *Sync Scene* feature.

[image reference removed]

The default Storyboarding App template.
user: How do I use Render in Blender? Include parameters, examples, warnings and best practices.

assistant: SMAA Threshold
:   Threshold for the edge detection algorithm used to correct aliasing for the final render,
    Higher values may result in loss of detail due to excessive blurring.

SSAA Samples
:   Number of samples used for super-sampling anti-aliasing in the final render.
    Higher values produce smoother lines but increase render time.

Motion Blur Steps
:   Controls accuracy of [motion blur](../../../glossary/index.html#term-Motion-Blur), more steps result in longer render time.
    Only used when [Motion Blur](motion_blur.html#bpy-types-rendersettings-use-motion-blur) is enabled.
    Set to 0 to disable motion blur for Grease Pencil objects.
user: Give a detailed overview of Attribute Type Items: syntax, arguments, return values, common patterns.

assistant: # Attribute Type Items

FLOAT:
:   Float.

    Floating-point value.

INT:
:   Integer.

    32-bit integer.

BOOLEAN:
:   Boolean.

    True or false.

FLOAT_VECTOR:
:   Vector.

    3D vector with floating-point values.

FLOAT_COLOR:
:   Color.

    RGBA color with 32-bit floating-point values.

QUATERNION:
:   Quaternion.

    Floating point quaternion rotation.

FLOAT4X4:
:   4x4 Matrix.

    Floating point matrix.

STRING:
:   String.

    Text string.

INT8:
:   8-Bit Integer.

    Smaller integer with a range from -128 to 127.

INT16_2D:
:   2D 16-Bit Integer Vector.

    16-bit signed integer vector.

INT32_2D:
:   2D Integer Vector.

    32-bit signed integer vector.

FLOAT2:
:   2D Vector.

    2D vector with floating-point values.

BYTE_COLOR:
:   Byte Color.

    RGBA color with 8-bit positive integer values.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: ### With Hotkeys

Press `G`, `R` or `S` and then hold either `Ctrl`,
`Shift` or `Shift`-`Ctrl`.

### With the Transform Gizmo

Select the gizmo handle then while moving the mouse hold `Ctrl`, `Shift` or `Shift`-`Ctrl`
to activate precision control or snapping.
user: What is AnnotationFrame(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AnnotationFrame(bpy_struct)

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

*class* bpy.types.AnnotationFrame(*bpy_struct*)
:   Collection of related sketches on a particular frame

    frame_number
    :   The frame on which this sketch appears

        Type:
        :   int in [-1048574, 1048574], default 0

    select
    :   Frame is selected for editing in the Dope Sheet

        Type:
        :   boolean, default False

    strokes
    :   Freehand curves defining the sketch on this frame

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`AnnotationStroke`](bpy.types.AnnotationStroke.html#bpy.types.AnnotationStroke "bpy.types.AnnotationStroke"), (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 Editing the Manual, preserving all code examples.

assistant: # Editing the Manual

You can modify the manual by editing local text files. These files are kept in sync with those online via a
repository, based on this the server will update the online manual.

The manual is written in the [reStructuredText](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html) (RST) markup language and can be edited
using a plain text editor. For a local preview, you convert (build) the manual source files from RST into HTML web
pages.
user: Describe Custom Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Create and manage your own properties to store data in the scene’s data block.
See the [Custom Properties](../../files/custom_properties.html#files-data-blocks-custom-properties) page for more information.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Curve
:   The input curve to generate the tube along.

Scale
:   Distance factor multiplied by the curve’s radius attribute to define the resulting tube radius.

### Profile

Profile Mode
:   Method used to define the profile shape of the tube.

    Round:
    :   Uses a circular profile to define the tube cross-section.

    Custom:
    :   Uses a custom object or geometry as the profile shape.

Resolution Round
:   The number of points around the circular profile.
    Also defines the resolution of the *Round* cap type.

Profile Input Custom
:   Defines how the custom profile is provided.

    Object:
    :   Uses a single object as the custom profile.

    Geometry:
    :   Uses input geometry directly as the profile.

Object / Geometry Custom
:   The specific object or geometry to use as the profile when *Custom* mode is active.

Shade Smooth
:   Enables smooth shading for the generated mesh.

### Resample

Resamples the input curve before generating the mesh.
This helps achieve evenly distributed geometry and consistent resolution along the tube.

Resample Mode
:   Determines how the curve is resampled.

    Evaluated:
    :   Uses the existing evaluated curve points.

    Auto:
    :   Automatically determines an appropriate sample length based on curve details.

    Count:
    :   Uses a fixed number of sample points.

    Length:
    :   Uses a fixed distance between sample points.

Scale Auto
:   Scale factor applied to the automatically derived resample length when using *Auto* mode.

Count Count
:   Number of sample points along the curve when using *Count* mode.

Length Length
:   Distance between sample points when using *Length* mode.

### Caps

Fills the open ends of the tube with cap geometry.

Caps Type
:   Method used to fill the tube ends.

    Flat:
    :   Uses a single n-gon to cap each end.

    Round:
    :   Uses a half-circle shape for rounded caps.

    Custom:
    :   Uses user-provided geometry or an object as the cap.

Smooth Flat Round
:   Smooths the transition between the tube body and the caps instead of creating a sharp edge.

Caps Input Custom
:   Defines how custom caps are provided.

    Object:
    :   Uses a single object as the custom cap.

    Geometry:
    :   Uses input geometry as the custom cap.

Start / End Custom
:   Specifies the objects or geometry to use for the start and end caps when *Custom* mode is active.

### UV Map

Name
:   The name of the UV map to create or modify on the output mesh.

Parameter U/V
:   Defines how the UVs are generated along the tube.

    Factor:
    :   Uses a normalized 0-1 factor along the curve and profile.

    Length:
    :   Maps UVs based on the real length of the curve and circumference.

    Index:
    :   Uses the point indices along the curve and profile.

Consider Curve Radius
:   When enabled, the UV generation takes into account variations in the curve’s radius.
user: Give a detailed overview of ShaderNodeTexGabor(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeTexGabor(ShaderNode)

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

*class* bpy.types.ShaderNodeTexGabor(*ShaderNode*)
:   Generate Gabor noise

    color_mapping
    :   Color mapping settings

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

    gabor_type
    :   The type of Gabor noise to evaluate

        - `2D`
          2D – Use the 2D vector (X, Y) as input. The Z component is ignored..
        - `3D`
          3D – Use the 3D vector (X, Y, Z) as input.

        Type:
        :   enum in [`'2D'`, `'3D'`], default `'2D'`

    texture_mapping
    :   Texture coordinate mapping settings

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type