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

assistant: [image reference removed]

Masks panel.

In Grease Pencil there are no special mask layers, any layer can act as a mask for other layers.
The mask system is flexible enough to allow top-bottom and bottom-top masking.

Layers used as masks can use all the blend modes and different opacity values like any other layer.

The layer/s that will act as mask of the current layer could be added
to the Mask [list view](../../interface/controls/templates/list_view.xhtml#ui-list-view).

In the Masks list next to the layers name there are two icons buttons that control
common properties of the layer mask:

Invert (mask icon)
:   Inverts the mask.

Viewport/Render Visibility (eye icon)
:   Toggle layer visibility in the viewport and in render.

Mask (green circle) samples.

|  |  |  |
| --- | --- | --- |
| ../../_images/grease-pencil_properties_masks_example-01.png   Original image (Blend: Regular, Opacity: 1). | ../../_images/grease-pencil_properties_masks_example-02.png   Blend: Hard Light, Opacity: 1. | ../../_images/grease-pencil_properties_masks_example-03.png   Blend: Regular, Opacity: 1. |
user: Explain Make Group in complete detail according to the official Blender documentation.

assistant: Creates a new node group that contains all selected nodes.

*Group Input* and *Group Output* nodes will be created to represent connections to unselected nodes outside the group.
Inputs will be routed to the *Group Input* and outputs routed to the *Group Output*.

When grouping a **single node**, the resulting node group will:

- Preserve the interface of the original node, including panels and default values.
- Inherit the name of the original node

When grouping **multiple nodes**, the group is created with inputs and outputs sockets generated from the connections.
In this case, a generic name such as “NodeGroup”, “NodeGroup.001”, etc. is used.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: The *Split* node is typically used for comparing two images directly in the compositor.
It can be connected to a [Viewer Node](../output/viewer.xhtml)
to preview before-and-after results, such as comparing an ungraded render against
a color-corrected version.

It can also be used to align transitions between scenes or shots by displaying
the last frame of one scene alongside the first frame of another,
helping ensure visual consistency.

[image reference removed]

Comparing two images using the Split node.
user: What is Color Ramp Widget and how is it used in Blender Python scripting?

assistant: # Color Ramp Widget

*Color Ramps* specify a color gradient based on color stops. Each stop has a position and a color.
The gradient is then calculated as the interpolation between these stops using the chosen
interpolation method.

[image reference removed]

Color ramp.
user: Provide the full official documentation entry for VIEW3D_FH_camera_background_image(FileHandler), preserving all code examples.

assistant: # VIEW3D_FH_camera_background_image(FileHandler)

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

*class* bpy.types.VIEW3D_FH_camera_background_image(*FileHandler*)
:   *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 Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Background
:   The background image.

Foreground
:   The foreground image to be placed over the background.

Factor
:   Controls the opacity of the foreground image, from 0 (fully transparent) to 1 (fully opaque).

Type
:   Determines the alpha compositing method:

    Over:
    :   The standard alpha-over operation.
        The foreground is placed over the background based on its alpha channel.

    Disjoint Over:
    :   Similar to *Over*, but assumes the background has been held out by the foreground,
        resulting in cleaner edges when compositing multiple layers.

    Conjoint Over:
    :   Similar to *Over*, but assumes the foreground overlaps or extends into the background.
        Useful when the foreground is more opaque but not fully opaque.

Straight Alpha
:   Specifies whether the foreground uses *straight* alpha (unpremultiplied) instead of *premultiplied* alpha.
    Most images in the compositor are premultiplied, so this should remain disabled in most cases.
    Enable it only if the foreground has been explicitly converted to straight alpha form.
user: Show practical ways to work with Advanced in a Blender add-on or script – include code.

assistant: ### Blender as a Module

From a Python perspective it’s nicer to have everything as an extension
which lets the Python script combine many components.

Advantages include:

- You can use external editors or IDEs with Blender’s Python API and execute scripts within the IDE
  (step over code, inspect variables as the script runs).
- Editors or IDEs can auto-complete Blender modules and variables.
- Existing scripts can import Blender APIs without having to be run inside of Blender.

This is marked advanced because to run Blender as a Python module requires a special build option.
For instructions on building see
[Building Blender as a Python module](https://developer.blender.org/docs/handbook/building_blender/python_module/).

### Python Safety (Build Option)

Since it’s possible to access data which has been removed (see [Gotchas](info_gotcha.html)),
it can be hard to track down the cause of crashes.
To raise Python exceptions on accessing freed data (rather than crashing),
enable the CMake build option `WITH_PYTHON_SAFETY`.
This enables data tracking which makes data access about two times slower
which is why the option isn’t enabled in release builds.
user: Show practical ways to work with Multi-View and Stereo 3D Image I/O in a Blender add-on or script – include code.

assistant: Multi-View and Stereo 3D
:   Multi-view images can be saved in special formats according to the production requirements.
    By default the system saves each view as an individual file,
    thus generating as many files as views to be rendered.
    In stereo 3D productions, for the final deployment or
    even intermediary previews it is convenient to save stereo 3D images,
    that are ready to use with 3D displays or simple anaglyph glasses.
    The formats supported match the display modes available for the window.

Lossy-Formats
:   Some stereo 3D formats represent a considerable loss of data.
    For example, the Anaglyph format will cap out entire color channels from the original image.
    The Top-Bottom compressed will discard half of your vertical resolution data.
    The Interlace will mash your data considerably.
    Once you export in those formats, you can still import the image
    back in Blender, for it to be treated as Stereo 3D.
    You will need to match the window stereo 3D display mode to the image stereo 3D format though.

Lossless Formats
:   Some formats will preserve the original data,
    leading to no problems on exporting and importing the files back in Blender.
    The Individual option will produce separate images that
    (if saved in a lossless encoding such as `PNG` or `OpenEXR`)
    can be loaded back in production with no loss of data.
    For the Stereo 3D formats the only lossless options are
    *Top-Bottom* and *Side-by-Side* without the Squeezed Frame option.

Multi-View OpenEXR
:   Another option is to use multi-view OpenEXR files. This format can save multiple views in
    a single file and is backward compatible with old OpenEXR viewers (you see only one view though).
    Multi-view native support is only available to OpenEXR.
user: Describe Extrude to Cursor from the Blender manual or Python API, including usage steps and snippets.

assistant: # Extrude to Cursor

Interactively places new vertices with `Ctrl`-`RMB` at the mouse cursor position.

The most basic element, a vertex, can be added with a `Ctrl`-`RMB` click
when no other vertices are selected.
Because the camera space (computer screen) is two-dimensional,
Blender cannot determine all three vertex coordinates from a single mouse click,
so the new vertex is placed at the depth of the 3D cursor.

To create interconnected vertices, you can add a vertex and continuously make subsequent `Ctrl`-`RMB`
operations with the last vertex selected.
This will link the last selected vertex with the vertex created at the mouse position with an edge
(see Fig. [Adding vertices one by one.](#fig-mesh-basics-add-one-tool)),
and will continuously create and connect new vertices if you continue repeating this operation.

[image reference removed]

Adding vertices one by one.
user: Provide the full official documentation entry for Color Sets, preserving all code examples.

assistant: [[image reference removed]](../../../_images/addons_rigging_rigify_metarigs_color-sets-panel.png)

The Color Sets panel is used to define the bone color scheme for the final rig. The colors from the list
can be associated with bone collections from the relevant panel.

The top two rows of the Color Sets panel are used to define the general behavior of the bone colors.
Usually color themes use a gradient of colors to define the different bone states: default, selected and active.
When multiple color themes are used in the same rig, identifying which bone is selected or
active can be tricky since each color will have its corresponding state.

To override this behavior Rigify unifies the active and selected states using the same color.
This is defined by two values:

Unified Selected/Active Colors
:   When this option is active adding a bone group in the list will always keep the colors consistent.
    When a color scheme is added from a theme, the color scheme is loaded as is.
    Click on the *Apply* button to force the system to unify selected and active colors.

Selected/Active Colors
:   This two color fields define respectively the *Selected* and *Active* colors.
    By default Rigify reads these colors from the theme defined by the user in the Blender preferences.
    This way the *Selected*/*Active* colors can always have a predictable and consistent behavior in the UI.
    The colors can be customized by clicking on the relevant color field.
    To reset them to the Blender current theme value just click on the button with the update icon.

Color Sets can be added and deleted by clicking on  or .
All color sets can be deleted at once by clicking on the Specials menu.

To add the colors from the predefined Rigify default color scheme (as shown in the image) to the list click
the *Add Standard* button.

To add a specific theme with its own color scheme, select it from the list and click on the *Add From Theme* button.
user: Provide the full official documentation entry for Corners of Edge Node, preserving all code examples.

assistant: # Corners of Edge Node

[image reference removed]

Selects a neighboring face corner of an edge and outputs its index.

This node is a bit special because it operates in two different domains.
First, it evaluates a *Weight* for each corner in the geometry.
Then, for each item in the context domain, it will:

- Pick an edge from the geometry based on the *Edge Index*.
- Find *some* (not all) face corners connected to this edge – see below.
- Sort these corners by their associated weight.
- Pick a corner from the above sorted list based on the *Sort Index*,
  where 0 means the corner with the lowest weight,
  1 means the corner with the second-lowest weight and so on.
- Output the geometry-wide index of this corner.

[[image reference removed]](../../../../_images/modeling_geometry-nodes_corners-of-edge_explanation.png)

A graphic for which corners are returned for a given edge

- Red: selected edge.
- Blue: the corners whose index can be retrieved using this node.
- Purple: the corners that can be retrieved by offsetting the blue corner indices using
  the [Offset Corner in Face Node](offset_corner_in_face.html).
user: Describe Context Access (bpy.context) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Context Access (bpy.context)

The context members available depend on the area of Blender which is currently being accessed.

Note that all context values are read-only,
but may be modified through the data API or by running operators.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Open 2D Curve

An open (non-cyclic) curve with beveling applied becomes a tube.

[[image reference removed]](../../../_images/modeling_curves_properties_geometry_extrude-open-curve.png)

### Closed 2D Curve

A closed (cyclic) curve with beveling applied becomes a torus by default.
If the curve is 2D and you set the [Fill Mode](shape.html#bpy-types-curve-fill-mode) to *Both*,
the top and bottom holes will be filled with flat discs, and you’ll get a cylinder
with rounded edges instead.

[[image reference removed]](../../../_images/modeling_curves_properties_geometry_extrude-closed-curve.png)

This doesn’t work with 3D curves.

### Taper

By selecting a 2D curve as the *Taper Object* of another (2D or 3D) curve,
you can let the radius of the latter curve’s geometry vary over the curve’s
length without having to create additional control points.

[image reference removed]

### Tilt

You can use the [Tilt](../editing/control_points.html#modeling-curve-tilt) tool to rotate a control point around
its tangent axis, creating a twist in the curve. The example below also uses
a custom profile (cross section).

[image reference removed]
user: Give a detailed overview of Python Console: syntax, arguments, return values, common patterns.

assistant: # Python Console

The Python Console offers a quick way to test code snippets and explore Blender’s API.
It executes whatever you type on its `>>>` prompt and has command history and auto-complete.

[image reference removed]

Python Console.
user: Explain CompositorNodeScale(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeScale(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.CompositorNodeScale(*CompositorNode*)
:   Change the size of the image

    *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: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`Context.area`](bpy.types.Context.html#bpy.types.Context.area "bpy.types.Context.area") | - [`Screen.areas`](bpy.types.Screen.html#bpy.types.Screen.areas "bpy.types.Screen.areas") |
user: What is KeyingSetsAll(bpy_struct) and how is it used in Blender Python scripting?

assistant: # KeyingSetsAll(bpy_struct)

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

*class* bpy.types.KeyingSetsAll(*bpy_struct*)
:   All available keying sets

    active
    :   Active Keying Set used to insert/delete keyframes

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

    active_index
    :   Current Keying Set index (negative for ‘builtin’ and positive for ‘absolute’)

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Primary Goals in complete detail according to the official Blender documentation.

assistant: The main goals for this manual are as follows:

User Focused
:   The manual is written for people educated in computer graphics, who understand the basics of 3D and/or know other
    3D software. While some areas of computer graphics are highly technical, this manual shall be kept understandable
    by non-technical users.

Complete
:   The manual provides detailed functional description of all features, tools and options in Blender. While there is a
    canonical source of truth for each of Blender’s key areas, this does not mean we have to document every small
    detail. The manual should provide information on what a feature is, how to use it, and its purpose. More background
    information should be provided when necessary to give deeper understanding of a 3D pipeline.

Concise
:   Computer graphics is an incredibly interesting field. There are many rules, exceptions to those rules, and
    interesting details. However, expanding into details can add unnecessary content; therefore, keep the text concise
    and relevant to the end user.

Maintainable
:   Keep in mind that Blender has frequent releases, so try to write content that will not have to be redone the moment
    some small change is made. This also helps a small documentation community maintain the manual.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`NodeClosureOutput.output_items`](bpy.types.NodeClosureOutput.html#bpy.types.NodeClosureOutput.output_items "bpy.types.NodeClosureOutput.output_items") - [`NodeClosureOutputItems.new`](bpy.types.NodeClosureOutputItems.html#bpy.types.NodeClosureOutputItems.new "bpy.types.NodeClosureOutputItems.new") | - [`NodeClosureOutputItems.remove`](bpy.types.NodeClosureOutputItems.html#bpy.types.NodeClosureOutputItems.remove "bpy.types.NodeClosureOutputItems.remove") |
user: How do I use Glow Strip in Blender? Include parameters, examples, warnings and best practices.

assistant: # Glow Strip

This effect makes parts of an image glow brighter by working on
the luminance channel of an image.
The *Glow* is the superposition of the base image and a modified version,
where bright areas are blurred.

To “animate” the glow effect,
mix it with the base image using the Gamma Cross effect,
crossing from the base image to the glowing one.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard geometry input.

Selection
:   Whether or not to change the position of each point or instance.
    True values mean the position will be changed, false values mean it will remain the same.

Position
:   The new position for selected elements. By default, this is the same as
    if the [Position Node](../read/position.xhtml) was connected,
    meaning the node will do nothing.

Offset
:   An optional translation for each point. This is evaluated at the same time as the *Position* input,
    meaning that fields evaluated for it will not reflect the changed position.
user: Give a detailed overview of NodeTreeInterfaceSocketVectorPercentage4D(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

assistant: # NodeTreeInterfaceSocketVectorPercentage4D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorPercentage4D(*NodeTreeInterfaceSocket*)
:   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)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

assistant: When you enable *Views* in the Render Layer panel, a new area is available in the 3D Viewport Sidebar region.
In this panel you can pick whether to see the stereo 3D in the viewport, or which camera to see.
It also allow you to see the *Cameras*, the *Plane* and the *Volume* of the stereo cameras.

[image reference removed]

Viewport stereo 3D settings.

Cameras
:   When working with the Stereo 3D Viewports setup, you can inspect what
    each individual generated camera is looking or the combined result of them.
    In the Multi-View mode you can see the combined result of the left and right cameras
    (when available) or the current selected camera.

Plane
:   The convergence plane represents the screen as it is perceived by the audience.
    Visualizing it in the 3D Viewport allows you to layout your scene
    based on your depth script outside the camera view.

Volume
:   The intersection of the stereo cameras frustums helps planning the show
    by avoiding elements being visible by only one camera.
    The volume is defined by the camera’s start and end clipping distances.
    The areas that are in the frustum of one camera only are known as *retinal rivalry areas*.
    They are tolerated in the negative space (the region from the convergence plane into the image)
    but are to be avoided at all costs in the positive space (the area from the convergence plane to the camera).

    [image reference removed]

    Viewport 3D: convergence plane and volume display.
user: How do I use Input in Blender? Include parameters, examples, warnings and best practices.

assistant: If you have a compact keyboard without a separate number pad, enable
Preferences ‣ Input ‣ Keyboard ‣ Emulate Numpad. This gives you the 3D view shortcuts regularly
used on the number pad.

If you do not have a middle mouse button, you can enable
Preferences ‣ Input ‣ Mouse ‣ Emulate 3 Button Mouse. This allows you to hold the `Alt`
or `OSKey` key while dragging with the mouse, to orbit.

See [Configuring Peripherals](hardware.html) for more information about these options, and see
[Input Preferences](../../editors/preferences/input.html) for details on configuring their settings.
user: Show practical ways to work with Sound Strip in a Blender add-on or script – include code.

assistant: # Sound Strip

As well as images and movies the Video Sequencer can also edit audio tracks.
You can add Waveform Audio format `WAV`, `mp3` and other audio formats files from your drive,
or from sound encoded within a movie, and mix them using an F-Curve as a volume control.

[image reference removed]

Example of sound editing.
user: Describe Face Corner Angle Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Face Corner Angle Node

[image reference removed]

The *Face Corner Angle* node outputs geometric information about the angle at each face corner
of a mesh. It can be used to analyze the shape of polygons, detect sharp corners, or create
procedural effects based on corner geometry.
user: Give a detailed overview of FunctionNodeInputInt(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeInputInt(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.FunctionNodeInputInt(*FunctionNode*)
:   Provide an integer value that can be connected to other nodes in the tree

    integer
    :   Input value used for unconnected socket

        Type:
        :   int in [-inf, inf], default 1

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

assistant: Fluid physics are used to simulate physical properties of liquids especially water.
While creating a scene in Blender, certain objects can be marked to become a part of the fluid simulation.
For a fluid simulation you have to have a domain to define the space that the simulation takes up.
In the domain settings you will be able to define the global simulation parameters (such as viscosity
and gravity).

[image reference removed]

Example of a liquid simulation.
user: Explain Battle in complete detail according to the official Blender documentation.

assistant: Health
:   Initial boid health when born.

Strength
:   Maximum caused damage per second on attack.

Aggression
:   Boid will fight this time stronger than enemy.

Accuracy
:   Accuracy of attack.

Range
:   Maximum distance of which a boid can attack.
user: Provide the full official documentation entry for Battle, preserving all code examples.

assistant: Health
:   Initial boid health when born.

Strength
:   Maximum caused damage per second on attack.

Aggression
:   Boid will fight this time stronger than enemy.

Accuracy
:   Accuracy of attack.

Range
:   Maximum distance of which a boid can attack.
user: Provide the full official documentation entry for Face, preserving all code examples.

assistant: ### Basic Concepts

#### Skin Bone Chains

[image reference removed]

The foundation of the Rigify face is a network of Bendy Bone [chains](rig_types/skin.xhtml#rigify-rigs-skin-basic-chain) with
controls placed at every bone end. These controls affect all bones that meet at that specific point.

When the controls are merely translated, the B-Bone chains retain the normal automatic bezier handle behavior.
Local rotation and/or scaling of the controls are applied on top of that.

In case of [certain chains](rig_types/skin.xhtml#rigify-rigs-skin-stretchy-chain), the transformation of the end and/or middle
controls is interpolated to other controls located between them. In such cases the controls often have different
colors and/or shapes.

Additionally, certain controls have [arbitrary constraints](rig_types/skin.xhtml#rigify-rigs-skin-glue) that partially copy
transformation from nearby control points.

#### Specialized Controllers

Certain areas of the face, like eyes or mouth, have additional specialized controllers that apply custom behavior
on top of the chains and their controllers within the relevant area.

### Eyes

[image reference removed]

The [eyes](rig_types/face.xhtml#rigify-rigs-face-skin-eye) have the following controls in addition to the eyelid chains:

Master
:   This large circular control can be used to transform the whole eye as one unit.

Common Target
:   This large control enveloping all individual eye targets has a switchable parent and can
    be used to specify the point that the eyes should look at.

Eye Target
:   These small circle controls within the common target control specify the point targeted by each
    individual eye. Their local scale can also be used to affect the iris or pupil of the eye,
    depending on how it was weight painted.

The rig properties panel contains the following options:

[image reference removed]

Eyelids Follow Slider
:   Controls how much the rotation of the eyeball affects the eyelids. Depending on the sub-rig generation
    options, this slider can be split to separately control the horizontal and vertical directions.

Eyelids Attached Slider Optional
:   If enabled in the sub-rig generation options, this slider can be used to disable the mechanism that
    forces the eyelids to conform to the sphere of the eye.

Parent Parent Switch
:   Selects the parent for the common target control.

### Mouth

[image reference removed]

The [mouth](rig_types/face.xhtml#rigify-rigs-face-skin-jaw) has the following controls:

Jaw Master
:   Controls rotation of the jaw, directly affecting the main jaw deform bone, as well
    as chains fully belonging to the jaw. Chains forming the lip loop(s) are adjusted to
    open the mouth as the jaw rotates or moves.

Mouth Master
:   This control uniformly transforms the lips without moving the jaw.

The rig properties panel contains the following options:

[image reference removed]

Mouth Lock Slider
:   This slider can be changed from 0 to 1 in order to suppress opening of the mouth
    when the jaw rotates or moves.
user: How do I use Toolbar in Blender? Include parameters, examples, warnings and best practices.

assistant: # Toolbar

Curves Edit Mode tools:

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

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

        All objects that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.xhtml#tool-select-circle)
    :   Select objects by dragging a circle. All objects that intersect the path of
        the circle will be selected.

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

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

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

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

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

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

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

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

[Draw](draw.xhtml#modeling-curves-draw)
:   Free-hand drawing of new curves.

[Radius](../editing/curves.xhtml#modeling-curves-radius)
:   Control the radius value of the control points.

[Tilt](../editing/control_points.xhtml#modeling-curves-tilt)
:   Control the rotation value of the control points around the curve’s axis.
user: How do I use Instance Rotation Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Instance Rotation Node

[image reference removed]

The *Instance Rotation* outputs the XYZ [Euler](../../../glossary/index.xhtml#term-Euler) rotation of each top-level instance in the
local space of the modifier object.

The [Instances](../instances.xhtml) page contains more information about geometry instances.
user: Describe ForeachGeometryElementMainItem(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ForeachGeometryElementMainItem(bpy_struct)

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

*class* bpy.types.ForeachGeometryElementMainItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

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

    socket_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

    *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 IMAGE_AST_brush_paint(AssetShelf) and how is it used in Blender Python scripting?

assistant: # IMAGE_AST_brush_paint(AssetShelf)

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

*class* bpy.types.IMAGE_AST_brush_paint(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *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 Known Limitations in a Blender add-on or script – include code.

assistant: ### Vertices Behind the Camera

When projecting geometry in a perspective view, vertices behind the camera are not properly mapped.
You can workaround this by subdividing geometry so that faces in front of the camera have correctly mapped UVs.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_knife-project_text-before.jpg>   Before projecting from a text object. | <../../../../_images/modeling_meshes_editing_mesh_knife-project_text-after.jpg>   Resulting knife projection. |
| <../../../../_images/modeling_meshes_editing_mesh_knife-project_mesh-before.jpg>   Before projecting from a mesh object. | <../../../../_images/modeling_meshes_editing_mesh_knife-project_mesh-after.jpg>   Resulting knife projection (extruded after). |
| <../../../../_images/modeling_meshes_editing_mesh_knife-project_curve-before.png>   Before projecting from a 3D curve object. | <../../../../_images/modeling_meshes_editing_mesh_knife-project_curve-after.jpg>   Resulting knife projection (extruded after). |
user: Explain Denoising in complete detail according to the official Blender documentation.

assistant: Even with all the settings described above there will always end
up being some render noise no matter how many samples you use.
To fix this there is a post-processing technique to cleanup the final bit of noise.
To use this enable [Denoising](../render_settings/sampling.html#render-cycles-settings-viewport-denoising)
in the *Render* tab of the Properties.

Below is an example render by
[The Pixelary](https://blog.thepixelary.com/post/160451378592/denoising-in-cycles-tested).

|  |  |
| --- | --- |
| ../../../_images/render_layers_denoising_example1.jpg   Example render before denoising. | ../../../_images/render_layers_denoising_example2.jpg   Example render after denoising. |
user: Explain Retopology in complete detail according to the official Blender documentation.

assistant: The automatic remesh tools generally don’t result in topology that lends itself to deformation.
Therefore, if you have sculpted a character and want to simplify it for animation,
you’ll typically have to do this manually in a process known as retopologizing.

To do this, you typically create a new mesh that overlaps the original one,
then adjust it until it fully covers the original mesh and matches its shape.

- The [Retopology](../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-retopology) overlay of the 3D Viewport is useful here,
  as it lets you see the original mesh through the retopologized one and vice versa –
  without getting distracted by geometry on the other side as would be the case with
  [X-Ray](../../editors/3dview/display/shading.xhtml#bpy-types-view3dshading-show-xray).
- You can use the [Poly Build](tools/poly_build.xhtml) tool to quickly add, change,
  and remove faces.
- Use [Snapping](../../editors/3dview/controls/snapping.xhtml) to align new vertices to the original mesh.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Closures define outputs that return values to the node tree in which they are evaluated.
Outputs can be created by dragging a socket from within the zone into the blank socket on the closure’s output, or by
adding sockets manually in the node’s properties.
user: Provide the full official documentation entry for GeometryNodeGridPrune(GeometryNode), preserving all code examples.

assistant: # GeometryNodeGridPrune(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.GeometryNodeGridPrune(*GeometryNode*)
:   Make the storage of a volume grid more efficient by collapsing data into tiles or inner nodes

    data_type
    :   Node socket data type

        Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

    *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 PointCacheItem(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PointCacheItem(bpy_struct)

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

*class* bpy.types.PointCacheItem(*bpy_struct*)
:   Point cache for physics simulations

    filepath
    :   Cache file path

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    frame_end
    :   Frame on which the simulation stops

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

    frame_start
    :   Frame on which the simulation starts

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

    frame_step
    :   Number of frames between cached frames

        Type:
        :   int in [1, 20], default 0

    index
    :   Index number of cache files

        Type:
        :   int in [-1, 100], default 0

    info
    :   Info on current cache status

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

    is_baked
    :   The cache is baked

        Type:
        :   boolean, default False, (readonly)

    is_baking
    :   The cache is being baked

        Type:
        :   boolean, default False, (readonly)

    is_frame_skip
    :   Some frames were skipped while baking/saving that cache

        Type:
        :   boolean, default False, (readonly)

    is_outdated
    :   Type:
        :   boolean, default False, (readonly)

    name
    :   Cache name

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

    use_disk_cache
    :   Save cache files to disk (.blend file must be saved first)

        Type:
        :   boolean, default False

    use_external
    :   Read cache from an external location

        Type:
        :   boolean, default False

    use_library_path
    :   Use this file’s path for the disk cache when library linked into another file (for local bakes per scene file, disable this option)

        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