PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of TextureNodeTree(NodeTree): syntax, arguments, return values, common patterns.

assistant: # TextureNodeTree(NodeTree)

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

*class* bpy.types.TextureNodeTree(*NodeTree*)
:   Node tree consisting of linked nodes used for textures

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

assistant: - Soft bodies work especially well if the objects have an even vertex distribution.
  You need enough vertices for good collisions. You change the deformation
  (the stiffness) if you add more vertices in a certain region.
- The calculation of collisions may take a long time. If something is not visible, why calculate it?
- To speed up the collision calculation it is often useful to collide with an additional,
  simpler, invisible, somewhat larger object.
- Use soft bodies only where it makes sense.
  If you try to cover a body mesh with a tight piece of cloth and animate solely with soft body,
  you will have no success. Self-collision of soft body hair may be activated,
  but that is a path that you have to wander alone. We will deal with
  [Collisions](collision.xhtml) in detail later.
- Try and use a *Lattice* or a *Curve Guide* soft body instead of the object itself. This may be magnitudes faster.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`MaskLayer.splines`](bpy.types.MaskLayer.html#bpy.types.MaskLayer.splines "bpy.types.MaskLayer.splines") - [`MaskSplines.active`](bpy.types.MaskSplines.html#bpy.types.MaskSplines.active "bpy.types.MaskSplines.active") | - [`MaskSplines.new`](bpy.types.MaskSplines.html#bpy.types.MaskSplines.new "bpy.types.MaskSplines.new") - [`MaskSplines.remove`](bpy.types.MaskSplines.html#bpy.types.MaskSplines.remove "bpy.types.MaskSplines.remove") |
user: How do I use Show/Hide in Blender? Include parameters, examples, warnings and best practices.

assistant: Contains operators to adjust the visibility of points and strokes in the viewport.

### Show All Layers

Shows all Grease Pencil [layers](../../properties/layers.html).

### Hide Active Layer

Hides the active Grease Pencil [layers](../../properties/layers.html).

### Hide Inactive Layers

Hides the all Grease Pencil [layers](../../properties/layers.html) except the active layer.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Vertex Index 1/2
:   The [index](../../geometry/read/input_index.xhtml) of the two vertices of the edge.

Position 1/2
:   The [position](../../geometry/read/position.xhtml) of each of the edge’s vertices.
    This output is for convenience, it is the same as using index output to retrieve the position from the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml).
user: Describe GeometryNodeMeshCube(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeMeshCube(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.GeometryNodeMeshCube(*GeometryNode*)
:   Generate a cuboid mesh with variable side lengths and subdivisions

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Pose

Deform a model simulating armature-like workflow.
This can either be useful for posing a model without a rig,
adjusting the proportions of a mesh or other fast deformations.

The brush will automatically determine an origin point,
indicated with a while line on the brush cursor.

If the [Deformation Target](../../brush/brush_settings.xhtml#bpy-types-brush-deform-target)
is changed, the brush can also be used for cloth sculpting.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeCaptureAttribute.capture_items`](bpy.types.GeometryNodeCaptureAttribute.html#bpy.types.GeometryNodeCaptureAttribute.capture_items "bpy.types.GeometryNodeCaptureAttribute.capture_items") - [`NodeGeometryCaptureAttributeItems.new`](bpy.types.NodeGeometryCaptureAttributeItems.html#bpy.types.NodeGeometryCaptureAttributeItems.new "bpy.types.NodeGeometryCaptureAttributeItems.new") | - [`NodeGeometryCaptureAttributeItems.remove`](bpy.types.NodeGeometryCaptureAttributeItems.html#bpy.types.NodeGeometryCaptureAttributeItems.remove "bpy.types.NodeGeometryCaptureAttributeItems.remove") |
user: Give a detailed overview of Battle: syntax, arguments, return values, common patterns.

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: Show practical ways to work with ShaderNodeSeparateColor(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeSeparateColor(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.ShaderNodeSeparateColor(*ShaderNode*)
:   Split a color into its individual components using multiple models

    mode
    :   Mode of color processing

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Viewer Node

[image reference removed]

The *Viewer* node allows viewing data from inside a geometry node group in both the
[Spreadsheet Editor](../../../editors/spreadsheet.xhtml) and the 3D Viewport.

Any geometry or attribute connected to the viewer can be visualized in the viewport,
and its evaluated attribute values can be inspected in the spreadsheet.
Other data can also be viewed and inspected such as scaler values and grids by showing them in the spreadsheet.
user: What is Modal Execution and how is it used in Blender Python scripting?

assistant: This operator defines a [`Operator.modal`](#bpy.types.Operator.modal "bpy.types.Operator.modal") function that will keep being
run to handle events until it returns `{'FINISHED'}` or `{'CANCELLED'}`.

Modal operators run every time a new event is detected, such as a mouse click
or key press. Conversely, when no new events are detected, the modal operator
will not run. Modal operators are especially useful for interactive tools, an
operator can have its own state where keys toggle options as the operator runs.
Grab, Rotate, Scale, and Fly-Mode are examples of modal operators.

[`Operator.invoke`](#bpy.types.Operator.invoke "bpy.types.Operator.invoke") is used to initialize the operator as being active
by returning `{'RUNNING_MODAL'}`, initializing the modal loop.

Notice `__init__()` and `__del__()` are declared.
For other operator types they are not useful but for modal operators they will
be called before the [`Operator.invoke`](#bpy.types.Operator.invoke "bpy.types.Operator.invoke") and after the operator finishes.
Also see the
[class construction and destruction section](info_overview.html#info-overview-class-construction-destruction).

```
import bpy

class ModalOperator(bpy.types.Operator):
    bl_idname = "object.modal_operator"
    bl_label = "Simple Modal Operator"
    bl_options = {'REGISTER', 'UNDO'}

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        print("Start")

    def __del__(self):
        print("End")
        super().__del__()

    def execute(self, context):
        context.object.location.x = self.value / 100.0
        return {'FINISHED'}

    def modal(self, context, event):
        if event.type == 'MOUSEMOVE':  # Apply.
            self.value = event.mouse_x
            self.execute(context)
        elif event.type == 'LEFTMOUSE':  # Confirm.
            return {'FINISHED'}
        elif event.type in {'RIGHTMOUSE', 'ESC'}:  # Cancel.
            # Revert all changes that have been made
            context.object.location.x = self.init_loc_x
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        self.init_loc_x = context.object.location.x
        self.value = event.mouse_x
        self.execute(context)

        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

# Only needed if you want to add into a dynamic menu.
def menu_func(self, context):
    self.layout.operator(ModalOperator.bl_idname, text="Modal Operator")

# Register and add to the object menu (required to also use F3 search "Modal Operator" for quick access).
bpy.utils.register_class(ModalOperator)
bpy.types.VIEW3D_MT_object.append(menu_func)

# Test call.
bpy.ops.object.modal_operator('INVOKE_DEFAULT')
```
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy.context.active_action`](bpy.context.html#bpy.context.active_action "bpy.context.active_action") - [`bpy.context.selected_editable_actions`](bpy.context.html#bpy.context.selected_editable_actions "bpy.context.selected_editable_actions") - [`bpy.context.selected_visible_actions`](bpy.context.html#bpy.context.selected_visible_actions "bpy.context.selected_visible_actions") - [`ActionConstraint.action`](bpy.types.ActionConstraint.html#bpy.types.ActionConstraint.action "bpy.types.ActionConstraint.action") - [`AnimData.action`](bpy.types.AnimData.html#bpy.types.AnimData.action "bpy.types.AnimData.action") - [`AnimData.action_tweak_storage`](bpy.types.AnimData.html#bpy.types.AnimData.action_tweak_storage "bpy.types.AnimData.action_tweak_storage") - [`BlendData.actions`](bpy.types.BlendData.html#bpy.types.BlendData.actions "bpy.types.BlendData.actions") - [`BlendDataActions.new`](bpy.types.BlendDataActions.html#bpy.types.BlendDataActions.new "bpy.types.BlendDataActions.new") | - [`BlendDataActions.remove`](bpy.types.BlendDataActions.html#bpy.types.BlendDataActions.remove "bpy.types.BlendDataActions.remove") - `GLTF2_filter_action.action` - [`NlaStrip.action`](bpy.types.NlaStrip.html#bpy.types.NlaStrip.action "bpy.types.NlaStrip.action") - [`NlaStrips.new`](bpy.types.NlaStrips.html#bpy.types.NlaStrips.new "bpy.types.NlaStrips.new") - [`Pose.apply_pose_from_action`](bpy.types.Pose.html#bpy.types.Pose.apply_pose_from_action "bpy.types.Pose.apply_pose_from_action") - [`Pose.backup_create`](bpy.types.Pose.html#bpy.types.Pose.backup_create "bpy.types.Pose.backup_create") - [`Pose.blend_pose_from_action`](bpy.types.Pose.html#bpy.types.Pose.blend_pose_from_action "bpy.types.Pose.blend_pose_from_action") - [`WindowManager.poselib_previous_action`](bpy.types.WindowManager.html#bpy.types.WindowManager.poselib_previous_action "bpy.types.WindowManager.poselib_previous_action") |
user: Describe Wayland from the Blender manual or Python API, including usage steps and snippets.

assistant: Support for Wayland is a more recent addition, so there may be configurations that have not been tested yet. Please
[report a bug](../../troubleshooting/report_bug.html) if you experience problems.

Blender has been tested with Gnome-Shell (mutter), KDE (plasma) & SWAY (wlroots) based compositors.

### Requirements

Gnome-Shell
:   Under Gnome-Shell the `libdecor` library is required. This is available as a package on most Linux distribution.

    If the library isn’t found X11 will be used as a fallback.

### Troubleshooting

Detailed Wayland output can help to track down problems. Launch Blender from the
[command-line](../../advanced/command_line/launch/linux.html) with additional arguments:

Blender’s Wayland Logging
:   ```
    blender --log "ghost.wl.*" --log-level 2
    ```

Wayland Built-In Logging
:   ```
    WAYLAND_DEBUG=1 blender
    ```

Disable Wayland (forcing X11)
:   ```
    WAYLAND_DISPLAY="" blender
    ```

Disable `libdecor` (forcing borderless windows under Gnome-Shell)
:   Uninstall `libdecor`, then run Blender with an empty X11 display variable.

    ```
    DISPLAY="" blender
    ```

### Environment Variables

`XCURSOR_THEME`
:   The cursor theme to use (must refer to a locally installed cursor).

`XCURSOR_SIZE`
:   The cursor size, defaults to 28, you may wish to increase the size on Hi-DPI displays.

### Known Limitations

Gnome Shell’s Fractional Scaling (before version 44)
:   Versions of Gnome-Shell prior to 44 don’t fully support fractional scaling.

    Using fractional under older versions of Gnome-Shell may result in glitches such as a [small cursor size](https://projects.blender.org/blender/blender/issues/105895).

NVIDIA GPU
:   Currently NVIDIA drivers don’t fully support features needed for Wayland. Graphical glitches and flickering are
    common problems. In some cases, there can be [crashes on startup](https://projects.blender.org/blender/blender/issues/103999). This is not specific to Blender, so NVIDIA users
    may want to use X11 until driver support improves.

---
user: Give a detailed overview of Combine Cylindrical Node: syntax, arguments, return values, common patterns.

assistant: # Combine Cylindrical Node

[image reference removed]

The *Combine Cylindrical* node converts cylindrical coordinates (R, Φ, Z)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Cylindrical](../../../../modeling/geometry_nodes/utilities/vector/separate_cylindrical.html) node.

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: Provide the full official documentation entry for Stereo 3D Camera, preserving all code examples.

assistant: When using the Stereo 3D scene view setup, a stereo pair is created
on-the-fly and used for rendering and previsualization.
For all the purposes this works as two cameras that share most parameters (focal length, clipping, …).
The stereo pair, however, is offset, and can have unique rotation and shift between itself.

[image reference removed]

Stereo 3D camera settings.

Interocular Distance
:   Set the distance between the camera pair.
    Although the convergence of a stereo pair can be changed in post-production,
    different interocular distances will produce different results
    due to the parts of the scene being occluded from each point of view.

Convergence Plane Distance
:   The converge point for the stereo cameras.
    This is often the distance between a projector and the projection screen.
    You can visualize this in the 3D Viewport.

Spherical Stereo
:   Render every pixel rotating the camera around the middle of the interocular distance.

Use Pole Merge
:   Fade interocular distance to 0 after the given cutoff angle.

    Pole Merge Start Angle
    :   Angle at which interocular distance starts to fade to 0.

    Pole Merge End Angle
    :   Angle at which interocular distance is 0.

### Convergence Mode

Off-Axis
:   The stereo camera pair is separated by the interocular distance,
    and shifted inwards so it converges in the convergence plane.
    This is the ideal format since it is the one closest to how the human vision works.

Parallel
:   This method produces two parallel cameras that do not converge.
    Since this method needs to be manually converged it cannot be used for viewing.
    This method is common when combining real footage with rendered elements.

Toe-in
:   A less common approach is to rotate the cameras instead of shifting their frustum.
    The Toe-in method is rarely used in modern 3D productions.

Pivot
:   The stereo pair can be constructed around the active camera with a new camera built for each eye
    (Center Pivot) or using the existing camera and creating (Left or Right).
    The latter is what is used when only one eye needs to be rendered for an existing mono 2D project.
user: Show practical ways to work with SDF Grid Mean Curvature Node in a Blender add-on or script – include code.

assistant: # SDF Grid Mean Curvature Node

[image reference removed]

The *SDF Grid Mean Curvature* node applies mean curvature flow smoothing to a Signed Distance Field (SDF) grid.
This operation evolves the surface of the field over time based on its mean curvature,
causing high-curvature (sharp or noisy) regions to smooth out more rapidly than flatter areas.

Unlike simple averaging or Laplacian smoothing, mean curvature flow adapts to
the geometric features of the surface, providing a more natural, shape-preserving
smoothing process. It can be used to refine complex SDF surfaces, remove small
artifacts, and create organically blended transitions between features.

This node is particularly effective after boolean operations or mesh-to-SDF
conversion, where the resulting fields may contain high-frequency noise.
user: Describe Bpy.Types.Compositornodecryptomattev2 from the Blender manual or Python API, including usage steps and snippets.

assistant: t_subclass Node.bl_rna_get_subclass_py NodeInternal.poll NodeInternal.poll_instance NodeInternal.update NodeInternal.draw_buttons NodeInternal.draw_buttons_ext NodeInternal.bl_rna_get_subclass NodeInternal.bl_rna_get_subclass_py CompositorNode.tag_need_exec CompositorNode.poll CompositorNode.update CompositorNode.bl_rna_get_subclass CompositorNode.bl_rna_get_subclass_py Next CompositorNodeCurveRGB(CompositorNode) Previous CompositorNodeCryptomatte(CompositorNode) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page CompositorNodeCryptomatteV2(CompositorNode) CompositorNodeCryptomatteV2 CompositorNodeCryptomatteV2.add CompositorNodeCryptomatteV2.entries CompositorNodeCryptomatteV2.frame_duration CompositorNodeCryptomatteV2.frame_offset CompositorNodeCryptomatteV2.frame_start CompositorNodeCryptomatteV2.has_layers CompositorNodeCryptomatteV2.has_views CompositorNodeCryptomatteV2.image CompositorNodeCryptomatteV2.layer CompositorNodeCryptomatteV2.layer_name CompositorNodeCryptomatteV2.matte_id CompositorNodeCryptomatteV2.remove CompositorNodeCryptomatteV2.scene CompositorNodeCryptomatteV2.source CompositorNodeCryptomatteV2.use_auto_refresh CompositorNodeCryptomatteV2.use_cyclic CompositorNodeCryptomatteV2.view CompositorNodeCryptomatteV2.is_registered_node_type() CompositorNodeCryptomatteV2.input_template() CompositorNodeCryptomatteV2.output_template() CompositorNodeCryptomatteV2.update() CompositorNodeCryptomatteV2.bl_rna_get_subclass() CompositorNodeCryptomatteV2.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with 2D Stabilization Panel in a Blender add-on or script – include code.

assistant: # 2D Stabilization Panel

The purpose of 2D stabilization is to smooth out jerky camera handling on existing real-world footage.
To activate the 2D stabilizer, you need to set the toggle in the panel, and additionally you need to enable
*Show Stable* in the Clip Display pop-over.
Then you’ll need to set up some tracking points to detect the image movements.

The 2D Stabilization panel is used to define the data used for 2D stabilization of the shot.
Several options are available in this panel: you may add a list of tracks to determine lateral image shifts
and another list of tracks to determine tilting and zooming movements.
Based on the average contribution of these tracks,
a compensating movement is calculated and applied to each frame.

When the footage includes panning and traveling movements,
the stabilizer tends to push the image out of the visible area.
This can be compensated by animating the parameters for the intentional,
“expected” camera movement.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Surface
:   The appearance of the environment.
    Usually connected to a [Background](../shader/background.html) shader.

Volume
:   Used to add volumetric effects to the world.
    See the shaders [Principled Volume](../shader/volume_principled.html),
    [Volume Absorption](../shader/volume_absorption.html),
    and [Volume Scatter](../shader/volume_scatter.html) for more information.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Subdivide modifier.

Subdivision Type
:   Catmull-Clark:
    :   Subdivides and smooths the surfaces.

    Simple:
    :   Only subdivides the surfaces, without any smoothing.

Subdivisions
:   Recursively adds more points.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: What is The Blender Community and how is it used in Blender Python scripting?

assistant: # The Blender Community

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

assistant: This scope visualizes the luminosity (brightness) distribution of the image,
letting you see at a glance if there’s enough contrast and if any areas are
under- or overexposed.

The scope works by plotting a curve for each scanline in the current video frame.
Another way of saying this is that each pixel column in the luma waveform
is a brightness histogram of the corresponding pixel column in the frame.
Specifically:

- The horizontal position of a pixel in the waveform refers to a pixel column in the frame.
- The vertical position of a pixel in the waveform refers to a brightness value,
  going from 0 at the bottom to 1 at the top.
- The brightness of a pixel in the waveform indicates how many pixels in the above frame column
  have the above brightness. If no pixels in the frame column have this brightness, the
  waveform pixel is black. If at least three pixels in the frame column have this brightness,
  the waveform pixel is white.

When this scope is selected, you have the following option in
Sidebar ‣ View ‣ View Settings:

The examples below show two images and their corresponding luma waveforms.

|  |  |
| --- | --- |
| ../../../../_images/video-editing_preview_display-mode_luma-waveform-example-1.png   The various horizontal lines in the luma waveform match the uniform-colored lines of the picture. Note that the ‘gray 20%’ one-pixel width line (inside the yellow strip) is represented in the Luma waveform by a gray line. The two lines drawing an “X” are from the two monochrome gradients. Finally, the broken line matches the colored gradient at the bottom. | ../../../../_images/video-editing_preview_display-mode_luma-waveform-example-2.png   The curves are quite visible. We found a luma of 80-100% for the sky, a luma around 40% for the sea, and a luma of 10-20% for the mountains, growing around 40% for the sunny part. |
user: What is Clay and how is it used in Blender Python scripting?

assistant: # Clay

Similar to the [Draw](draw.xhtml) brush,
but includes settings to adjust the [sculpt plane](../../brush/brush_settings.xhtml#bpy-types-brush-sculpt-plane)
on which the brush acts. That’s because it behaves like a combination of the
[Plane](plane.xhtml) and *Draw* brushes.

This brush is useful for building and removing volumes and shapes like real clay,
because it flattens details as you add/subtract from the surfaces.

If used together with [Dyntopo](../tool_settings/dyntopo.xhtml#bpy-ops-sculpt-dynamic-topology-toggle)
it’s easy to continuously build shapes, even in a single stroke.
user: Provide the full official documentation entry for Array Modifier, preserving all code examples.

assistant: # Array Modifier

The *Array* modifier creates an array of copies of the base object, with each copy being offset from
the previous one in any of a number of possible ways.

Useful for creating complex repetitive drawings.

Multiple Array modifiers may be active for an object at the same time
(e.g. to create complex three-dimensional constructs).
user: Explain Corners of Vertex Node in complete detail according to the official Blender documentation.

assistant: # Corners of Vertex Node

[image reference removed]

Selects a neighboring face corner of a vertex 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 a vertex from the geometry based on the *Vertex Index*.
- Find the face corners adjacent to this vertex.
- 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.
user: Provide the full official documentation entry for Output, preserving all code examples.

assistant: Standard Deviation
:   The square root of the variance, describing the spread of values.

Variance
:   A measure of the average squared deviation from the mean.
    Higher values indicate more variation in the input field.
user: Provide the full official documentation entry for Post Processing, preserving all code examples.

assistant: # Post Processing

The Post Processing panel is used to control different options used to process your image after rendering.

[image reference removed]

Post Processing panel.

Pipeline – Compositing
:   Renders the output from the compositing node setup,
    and then applies the Composite node tree on all images,
    displaying the image inputted in the Group Output node.

Pipeline – Sequencer
:   Renders the output of the Video Sequence editor, instead of the view from the 3D scene’s active camera.
    If the sequence contains Scene strips, these will also be rendered as part of the pipeline.
    If *Compositing* is also enabled, the Scene strip will be the output of the Compositor.

Dither
:   Dithering is a technique for blurring pixels to prevent banding that is seen in areas of
    gradients, where stair-stepping appears between colors.
    Banding artifacts are more noticeable when gradients are longer, or less steep.
    Dithering was developed for graphics with low bit depths,
    meaning they had a limited range of possible colors.

    Dithering works by taking pixel values and comparing them with a threshold and
    neighboring pixels then does calculations to generate the appropriate color.
    Dithering creates the perceived effect of a larger color palette by creating a sort of visual color mixing.
    For example, if you take a grid and distribute red and yellow pixels evenly across it,
    the image would appear to be orange.
user: Show practical ways to work with Render Baking in a Blender add-on or script – include code.

assistant: # Render Baking

Cycles shaders and lighting can be baked to image textures.
This has a few different purposes, most commonly:

- Baking textures like base color or normal maps for export to game engines.
- Baking ambient occlusion or procedural textures,
  as a base for texture painting or further edits.
- Creating light maps to provide global illumination or speed up rendering in games.
user: What is CacheObjectPaths(bpy_struct) and how is it used in Blender Python scripting?

assistant: # CacheObjectPaths(bpy_struct)

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

*class* bpy.types.CacheObjectPaths(*bpy_struct*)
:   Collection of object paths

    *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 Whole Character Keying Set, preserving all code examples.

assistant: The built-in *Whole Character* Keying Set is made to keyframe all properties
that are likely to get animated in a character rig.

This keying set ignores bones whose name starts with one of the following prefixes,
as it assumes these are technical bones that are not meant to be animated directly.
The built-in Rigify addon generates such bones, for example.

- COR (Corrective)
- DEF (Deformation)
- GEO (Geometry)
- MCH (Mechanism)
- ORG (Original from meta rig)
- VIS (Visualization)
user: Give a detailed overview of Corners of Edge Node: syntax, arguments, return values, common patterns.

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]

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

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

assistant: A mesh can have more than one UV map, where each map can assign different UV coordinates
to the same 3D vertex. This is useful if, say, you need one UV map for textures and another
for storing [prebaked lighting](../../editing/uv.html#bpy-ops-uv-lightmap-pack).

You can add and remove UV maps in the [UV Maps panel](../uv_texture_spaces.html#uv-maps-panel).
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

The Clip View is the main part of the Movie Clip editor;
almost all motion tracking tools are concentrated within the Clip View.

It should be mentioned that the camera solver consists of three quite separate steps:

1. 2D tracking of footage.
2. Camera intrinsics (focal length, distortion coefficients) specification/estimation/calibration.
3. Solving camera, scene orientation, and scene reconstruction.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Glass profile.

First, create a mesh representing the profile of your object.
If you are modeling a hollow object, it is a good idea to thicken the outline.
Fig. [Glass profile.](#fig-mesh-spin-glass) shows the profile for a wine glass we will model as a demonstration.

We will be rotating the object around the cursor in the top view,
so switch to the top view with `Numpad7`.

[image reference removed]

Glass profile, top view in Edit Mode, just before spinning.

Place the cursor along the center of the profile by entering Edit Mode
and selecting one of the vertices along the center, and snapping the 3D cursor to
that location with Mesh ‣ Snap ‣ Cursor to Selection.
(Fig. [Glass profile, top view in Edit Mode, just before spinning.](#fig-mesh-spin-glass-top)) shows the wine glass profile from
top view, with the cursor correctly positioned.

Select all the vertices with `A` and select the *Spin* tool from the Toolbar
and use the Gizmo to spin the vertices. Fig. [Spun profile.](#fig-mesh-spin-profile) shows the result of a successful spin.

### Angle

Spun profile.

|  |  |
| --- | --- |
| ../../../_images/modeling_meshes_tools_spin_spun-profile360.png   Spun profile using an angle of 360. | ../../../_images/modeling_meshes_tools_spin_spun-profile120.png   Spun profile using an angle of 120. |

### Duplicate

|  |  |
| --- | --- |
| ../../../_images/modeling_meshes_tools_spin_result.png   Result of spin operation. | ../../../_images/modeling_meshes_tools_spin_dubli.png   Result of *Duplicate* enabled. |

### Merge Duplicates

[image reference removed]

Duplicate vertices.

The spin operation leaves duplicate vertices along the profile.
You can select all vertices at the seam with Box select `B`
(shown in Fig. [Duplicate vertices.](#fig-mesh-screw-duplicate)) and perform a *Merge by Distance* operation.

Notice the selected vertex count before and after the *Merge by Distance* operation
`Vertex count after removing doubles`. If all goes well, the final vertex count
(38 in this example) should match the number of the original profile noted in
Mesh data ‣ Vertex and face numbers.
If not, some vertices were missed and you will need to weld them manually.
Or, worse, too many vertices will have been merged.

### Recalculate Normals

All that remains now is to recalculate the normals to the outside by selecting all vertices,
pressing `Alt`-`N` and validating *Recalculate Normals Outside* in the pop-up menu.
user: How do I use Lens in Blender? Include parameters, examples, warnings and best practices.

assistant: Focal Length
:   The focal length with which the movie was shot.
    It can be set in millimeters or pixels.

Optical Center
:   Defines the optical center (also known as the *principal point*) of the lens used by the camera.
    In most cases this coincides with the center of the image, but certain lenses may have
    an offset optical center. Refer to the specifications of camera or lens used if needed.

    The values are given in normalized image coordinates.

Lens Distortion
:   Mathematical function to convert distorted to undistorted coordinates.

    Polynomial:
    :   Polynomial radial distortion. Uses three distortion coefficients: K1, K2, and K3.

    Division:
    :   It defines high distortions, which makes this model suitable much better for cameras with fisheye lenses.
        Use two distortion coefficients: K1, K2.

    Nuke:
    :   Distortion model used by the Nuke compositor. Use two distortion coefficients K1, K2.

    Brown:
    :   Brown-Conrady is one of most advanced mathematical lens distortion models.
        Used to model both radial and tangential distortion. Can use up to four
        radial distortion coefficients: K1 - K4 and up to two tangential distortion coefficients: P1 and P2.

Coefficients
:   Coefficients are used to compensate for lens distortion when the movie was shot.
    Currently these values can be tweaked by hand only (there are no calibration tools yet)
    using tools available in Distortion mode. To do this tweak K1 until the solving is the closest to
    the known focal length (but also take grid and annotations into account
    to prevent “impossible” distortion).

    Radial Distortion Coefficients (K1 - K4)
    :   The coefficients in lens distortion models work independent from each other.
        Positive values will give a barrel distortion while negative values give a pincushion distortion.
        With a mixture of both negative and positive coefficients you can define more complicated
        mustache distortions or other complex distortions, that are less common but not rare.

        [image reference removed]

        Example of radial distortion for positive and negative K coefficients.

    Tangential Distortion Coefficients (P1, P2)
    :   Works independent and allow to compensate for situations when the sensor is not
        perpendicular to a group of lens. The optical center (also called principal point)
        will be shifted (distorted) from the center of the sensor.
        P1 is used to compensate for sensor rotation in Z (vertical) axes,
        while P2 is for compensating sensor rotation in X (horizontal) axes.
        Such distortions can be found in sources from cameras with a sensor stabilization system.

        [image reference removed]

        Example of tangential distortion for P coefficients.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Floor constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone that defines the location, and optionally the rotation, of the floor.

Offset
:   Moves the virtual floor “up” or “down” by a certain distance. This makes it possible to,
    say, make foot bones stay a certain distance above the floor geometry to leave room for
    the actual feet.

Min/Max
:   The axis that’s perpendicular to the floor and points towards its “walkable” area.
    Setting this to Z creates a floor; X or Y creates a wall; and -Z creates a ceiling.

    By default, these axes correspond to the global axes.

Use Rotation
:   Use the *Target*’s local axes for *Min/Max* instead of the global axes.

[Target/Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The spaces for evaluating and limiting the coordinates of the target and owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Give a detailed overview of GeometryNodeFilletCurve(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeFilletCurve(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.GeometryNodeFilletCurve(*GeometryNode*)
:   Round corners by generating circular arcs on each control point

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

assistant: # GeometryNodeSetGridBackground(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.GeometryNodeSetGridBackground(*GeometryNode*)
:   Set the background value used for inactive voxels and tiles

    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: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`CompositorNodeConvertToDisplay.display_settings`](bpy.types.CompositorNodeConvertToDisplay.html#bpy.types.CompositorNodeConvertToDisplay.display_settings "bpy.types.CompositorNodeConvertToDisplay.display_settings") - [`ImageFormatSettings.display_settings`](bpy.types.ImageFormatSettings.html#bpy.types.ImageFormatSettings.display_settings "bpy.types.ImageFormatSettings.display_settings") | - [`Scene.display_settings`](bpy.types.Scene.html#bpy.types.Scene.display_settings "bpy.types.Scene.display_settings") |
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: [image reference removed]

This example shows how to use the *Curves to Grease Pencil* node to create a Grease Pencil layer from a curve.

The *Set Curve Radius* node is used to set the radius of the Grease Pencil strokes.