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

assistant: # NodeTreeInterfaceSocketStringFilePath(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.NodeTreeInterfaceSocketStringFilePath(*NodeTreeInterfaceSocket*)
:   String socket of a node

    default_value
    :   Input value used for unconnected socket

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

    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: Show practical ways to work with Vertex Paint Options in a Blender add-on or script – include code.

assistant: Selection Mask
:   Vertex Paint Mode in Grease Pencil allows you to select points or strokes to restrict the effect
    of the painting tools to only a certain areas of your drawing.

    You can use the selection tools in the Toolbar for a quick selections.

    You can restrict painting only on the selected points or strokes with the Selection mode toggle.
    The three modes can be toggled with `1`, `2`, or `3` respectively.

Multiframe
:   Sometimes you may need to modify several frames at the same time with the painting tools.

    You can activate multiframe editing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../../multiframe.html) for more information.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Key Color
:   The color that is to be keyed.

Color Space
:   It is also possible to work with YCbCr color space,
    but only the Cb and Cr channels are taken into consideration
    for determining the distance between the foreground and background pixels.

    RGB, YCC

Tolerance
:   A threshold what the node considers a match between the key color and the foreground pixel.
    The tolerance affects how close a pixel needs to be to the background pixel
    to be considered an absolute match.

Falloff
:   When the Falloff value is high, pixels that are close to the Key Color are more
    transparent than pixels that are not as close to the Key Color
    (but still considered close enough to be keyed).
    When the Falloff value is low, it does not matter how close
    the pixel color (Image) is to the Key Color, it is transparent.
user: Describe CompositorNodeBilateralblur(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeBilateralblur(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.CompositorNodeBilateralblur(*CompositorNode*)
:   Adaptively blur image, while retaining sharp edges

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Your computer accidentally turns off in the middle of rendering your movie!
:   Unless your animation renders in a few minutes,
    it is best to render the animation as separate image files.
    Instead of rendering directly to a compressed movie file, use a lossless format (e.g. `PNG`).

    This allows you an easy recovery if there is a problem and you have to re-start the rendering,
    since the frames you have already rendered will still be in the output directory.

    Just disable the *Overwrite* option to start rendering where you left off.

    You can then make a movie out of the separate frames with Blender’s Sequence editor
    or use 3rd party encoding software.

Animation Preview
:   It can be useful to render a subset of the animated sequence,
    since only part of an animation may have an error.

    Using an image format for output,
    you can use the *Frame Step* option to render every *N’th* frame.
    Then disable *Overwrite* and re-render with *Frame Step* set to 1.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The input geometry to displace.

Selection
:   Determines which elements of the geometry are affected by the displacement.
    Unselected elements remain unchanged.

Strength
:   The distance to move each element along the chosen offset direction or vector.

Offset Method
:   Determines how the displacement direction is defined.

    Normal:
    :   Offsets elements along their surface normal direction.

    Vector:
    :   Offsets elements according to a custom input vector.

Offset Distance Normal
:   The displacement distance when using *Normal* mode.

Offset Vector Vector
:   The displacement vector when using *Vector* mode.
    The vector is normalized internally unless otherwise specified.

Substeps
:   The number of intermediate steps to divide the displacement into.
    Fields, including normal and position, are re-evaluated at each substep for more stable
    or accurate iterative results.

Post Substep Process
:   A [Node Closures](../../utilities/closure/index.html)
    that defines a geometry operation to apply after each substep of the displacement.
    This allows additional geometry processing to be performed during the iterative displacement.

    The closure has the following parameters:

    - **Geometry** – The geometry at the current substep.
    - **Selection** – The selected elements at that stage.
    - **Strength** – The displacement strength for the substep.
    - **Substep Index** – The current substep iteration number.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be rotated.

Transform
:   The transformation matrix to translate, rotate, and scale individual instances.
user: Explain Node Boolean Math Items in complete detail according to the official Blender documentation.

assistant: # Node Boolean Math Items

AND:
:   And.

    True when both inputs are true.

OR:
:   Or.

    True when at least one input is true.

NOT:
:   Not.

    Opposite of the input.

---

NAND:
:   Not And.

    True when at least one input is false.

NOR:
:   Nor.

    True when both inputs are false.

XNOR:
:   Equal.

    True when both inputs are equal (exclusive nor).

XOR:
:   Not Equal.

    True when both inputs are different (exclusive or).

---

IMPLY:
:   Imply.

    True unless the first input is true and the second is false.

NIMPLY:
:   Subtract.

    True when the first input is true and the second is false (not imply).
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Width
:   The number of pixels along the X axis. Specific to each frame.

Height
:   The number of pixels along the Y axis. Specific to each frame.

Has Alpha
:   Whether the transparency channel be different from 1 for the pixels of this image frame. Specific to each frame.

Frame Count
:   The number of frames in an image or video frame sequence. For a static image, always 1.

FPS
:   The number of frames per second. For static image is always 0.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Distribution Method
:   Random:
    :   Distribute points randomly on the surface. This is the fastest distribution method.

    Poisson Disk:
    :   Distribute points randomly on the surface while taking a minimum distance into account.

Legacy Normal
:   By default, the node uses smooth and custom normals for the *Normal* and *Rotation* values .
    An earlier version of this node only uses “true” normals,
    this option brings back this behavior of only using “true” normals.

    This option can only be available in the Sidebar.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleAlphaModifier.name`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier.name "bpy.types.LineStyleAlphaModifier.name") |
user: Describe Bake Items from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Bake Items* panel is used to manage the input sockets
of the node thus also managing what data is baked.

Bake Items List
:   Used to manage the inputs and outputs of the bake node.
    Items can be added, removed, renamed, and sorted.

Socket Type
:   The data ([Sockets](../../../../interface/controls/nodes/parts.xhtml#bpy-types-nodelink)) of the input/output.

Attribute Domain
:   The [attribute domain](../../attributes_reference.xhtml#attribute-domains) used to evaluate the input field on.

Is Attribute
:   Bake item is an attribute stored on a geometry.
user: What is Admonitions and how is it used in Blender Python scripting?

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

Common admonition types include:

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

Admonitions are created using the following markup:

```
.. note::

   This is a note for general information.
```

Other types can be rendered by replacing `note` with the desired type from the list above.
user: Give a detailed overview of Using an External Image Editor: syntax, arguments, return values, common patterns.

assistant: If you use an external program to edit your UV texture, you must:

1. Run that paint program (GIMP, Krita, etc.).
2. Load the image or create a new one.
3. Change the image.
4. And re-save it within that program.
5. Back in Blender, you reload the image in the Image Editor.

You want to use an external program if you have teams of people using different programs
that are developing the UV textures, or if you want to apply any special effects
that Texture Paint does not feature, or if you are much more familiar with
your favorite paint program.
user: Describe GeometryNodeUVUnwrap(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeUVUnwrap(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.GeometryNodeUVUnwrap(*GeometryNode*)
:   Generate a UV map based on seam edges

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

assistant: # CacheObjectPath(bpy_struct)

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

*class* bpy.types.CacheObjectPath(*bpy_struct*)
:   Path of an object inside of an Alembic archive

    path
    :   Object path

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

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

assistant: ### Invalid Selection

There are times when selection fails under some configurations. Often, this is noticeable in mesh *Edit Mode*,
selecting vertices/edges/faces where random elements are selected.

Internally Blender uses [OpenGL](../glossary/index.xhtml#term-OpenGL) for selection, so the graphics card driver requires Blender to give it correct
results in the format it expects.

Possible Solutions:

Disable [Multisampling](../glossary/index.xhtml#term-Multisampling)
:   This is by far the most common cause of selection issues.

    There are known problems with some graphics cards when using multisampling.

    You can disable this option by turning multisampling off in your graphics card driver options.

Change Anti-Aliasing Sample Settings
:   Depending on your OpenGL configuration, some specific sample settings may work while others fail.

    Unfortunately finding a working configuration involves trial & error testing.

Upgrade Graphics Driver
:   As with any OpenGL-related issues, using recent drivers can resolve problems.

    However, it should be noted that this is a fairly common problem and remains unresolved with many drivers.
user: Explain Playback Controls in complete detail according to the official Blender documentation.

assistant: The Playback Controls region contains controls and options
related to playback, keying, auto keyframing, and transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.
user: Provide the full official documentation entry for Cryptomatte Node, preserving all code examples.

assistant: # Cryptomatte Node

[image reference removed]

The Cryptomatte node uses a [Cryptomatte image](https://en.wikipedia.org/wiki/Cryptomatte)
to create a mask for one or more objects or materials. The input matte is typically generated by
Blender itself (see the [Cryptomatte render pass](../../../render/layers/passes.xhtml#render-layers-passes-cryptomatte)),
but can also come from other software that supports the standard.
user: How do I use Limit Location Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Limit Location Constraint

The *Limit Location* constraint forces an object or bone to stay above a coordinate,
below a coordinate, or between two coordinates along one or more axes.

Like other constraints, *Limit Location* only looks at the [origin](../../../scene_layout/object/origin.html)
for objects; their geometry is not taken into account. This means that, if a cube’s origin
is at its center and a *Limit Location* constraint is added for the coordinates of a
floor plane, the cube will still be able to sink halfway into the plane.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: In the properties panel, each field input can be configured individually.
This includes setting its **data type** (such as *Float*, *Vector*, or *Boolean*)
and managing the order of evaluation.
Each field input produces a corresponding output grid.
user: Explain GeometryNodeGridCurl(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeGridCurl(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.GeometryNodeGridCurl(*GeometryNode*)
:   Calculate the magnitude and direction of circulation of a directional vector grid

    *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 Outputs and how is it used in Blender Python scripting?

assistant: Attachment UV
:   The UV coordinates on the surface where each curve is attached.
    These are typically stored per curve and used to find the correct attachment
    location even if the surface topology changes.

Attachment is Valid
:   A boolean output indicating whether each curve has a valid stored attachment.
    This can be used to detect invalid or missing attachment data after topology edits
    or surface replacement.

Surface Normal
:   The normal direction of the surface mesh evaluated at the curve’s attachment point.
    This can be used for aligning hair roots, orienting instances, or driving deformation
    based on surface orientation.
user: Provide the full official documentation entry for Updating on Linux, preserving all code examples.

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

### Updating from blender.org

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

### Updating with a Package Manager

Many Linux distributions have packages for Blender available, which can be installed using the distribution’s package
manager. After installation, Blender can be updated using the same steps as updating any other application.
user: Provide the full official documentation entry for ShaderNodeCustomGroup(ShaderNode), preserving all code examples.

assistant: # ShaderNodeCustomGroup(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.ShaderNodeCustomGroup(*ShaderNode*)
:   Custom Shader Group Node for Python nodes

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

    *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 TextureNodeChecker(TextureNode), preserving all code examples.

assistant: # TextureNodeChecker(TextureNode)

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

*class* bpy.types.TextureNodeChecker(*TextureNode*)
:   *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 Array (Legacy) Modifier: syntax, arguments, return values, common patterns.

assistant: # Array (Legacy) 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. Vertices in adjacent copies can be merged if they are nearby,
allowing smooth [Subdivision Surface](subdivision_surface.html)
frameworks to be generated.

This modifier can be useful when combined with tileable meshes for quickly developing large scenes.
It is also useful for creating complex repetitive shapes.

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

assistant: # Troubleshooting macOS – NVIDIA

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: How do I use Plane in Blender? Include parameters, examples, warnings and best practices.

assistant: # Plane

Moves vertices toward or away from the brush plane along its normal direction.

The *Plane* brush flattens geometry to a virtual plane
or raises the surface relative to it, depending on brush settings.
The *Height* and *Depth* parameters control the range of influence above and below the plane,
allowing precise shaping of flat surfaces or plateaus.
user: Give a detailed overview of GeometryNodeInputMeshEdgeVertices(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeInputMeshEdgeVertices(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.GeometryNodeInputMeshEdgeVertices(*GeometryNode*)
:   Retrieve topology information relating to each edge of a mesh

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

assistant: These operators smooths geometry patches based of a [Face set](face_sets.xhtml).

Fair Positions
:   Creates a perfectly flat and smooth geometry patch from the face set.
    This is the ideal way to trim parts of your mesh
    if the vertex count is too high for other operations,
    or the vertex IDs must not be altered
    (Like when using [Multires](../../../modeling/modifiers/generate/multiresolution.xhtml) sculpting).

Fair Tangency
:   Creates a smooth as possible geometry patch from the face set
    by minimizing changes in vertex [tangents](../../../glossary/index.xhtml#term-Tangent).
    This is ideal for creating smooth curved surfaces on complex topology,
    where just using the smooth brush will not lead to desired results
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Segments
:   Horizontal resolution of the sphere.
    If this is smaller than three, no mesh is generated.

Rings
:   Vertical resolution of the sphere.
    If this is smaller than two, no mesh is generated.

Radius
:   Distance of vertices to the origin.
user: How do I use Viewport Display in Blender? Include parameters, examples, warnings and best practices.

assistant: # Viewport Display

The Display Panel controls how particles are displayed in the 3D Viewport.
This does not necessarily determine how they will appear when rendered.

Display As
:   None
    :   The particles are not shown in the 3D Viewport and are not rendered.
        The emitter may be rendered though.

    Rendered
    :   Particles are displayed the way they are rendered.

    Point
    :   Particles are displayed as square points.
        Their size is independent of the distance from the camera.

    Circle
    :   Particles are displayed as circles that face the view.
        Their size is independent of the distance from the camera.

    Cross
    :   Particles are displayed as 6-point crosses that align to the rotation of the particles.
        Their size is independent of the distance from the camera.

    Axis
    :   Particles are displayed as 3-point axes.
        This is useful if you want to see the orientation and rotation of particles in the viewport.
        Increase the *Display Size* until you can clearly distinguish the axis.

Color
:   The Color Menu allows you to display particle’s color according to certain particle properties.

    None
    :   Particles are black.

    Material
    :   Particles are colored according to the material they are given.

    Velocity
    :   Color particles according to their speed.
        The color is a ramp from blue to green to red, Blue being the slowest,
        and Red being velocities approaching the value of *Max* or above.
        Increasing *Max* allows for a wider range of particle velocities.

    Acceleration
    :   Color particles according to their acceleration.

Amount
:   Specifies the percentage of all particles to show in the viewport (all particles are still rendered).

Show Emitter
:   Make instancer visible in viewport.
user: Explain Scripted Expression - Orbit a Point in complete detail according to the official Blender documentation.

assistant: Orbit an object’s position around a point with a custom *Scripted Expression*.
The object’s position will change when scrubbing the timeline.
Using trigonometry, circular motion can be defined in 2D using the sine and cosine functions.
(See [Unit Circle](https://en.wikipedia.org/wiki/Unit_circle).)
In this example, the current frame is used as the variable that induces the motion.
`frame` is a [Simple Expression](drivers_panel.xhtml#drivers-simple-expressions) that corresponds to
`bpy.context.scene.frame_current`.

[image reference removed]

1. Add a driver to the X Location property.

   1. Set the *Driver Type* to *Scripted Expression*.
   2. Add the expression `0 + (sin(frame / 8) * 4)`, where:

      - `frame/8` : is the current frame of the animation, divided by 8 to slow the orbit down.
      - `(sin( )*4)` : multiplies the result of `sin(frame/8)` by 4 for a bigger circle.
      - `0 +` : is used to control the offset to the orbit center point.
2. Add a driver to the Y Location property with the expression `0 + (cos(frame / 8) * 4)`.
3. Scrub the timeline to see the effect.
   Experiment with the variables to control the size and center of the orbit.
user: Give a detailed overview of Goal: syntax, arguments, return values, common patterns.

assistant: # Goal

Enabling this tells Blender to use the motion from animations
(F-Curves, armatures, parents, lattices, etc.) in the simulation.
The “goal” is the desired end position for vertices based on this animation.

See [exterior forces](../forces/exterior.xhtml#physics-softbody-forces-exterior-goal) for details.

Vertex Group
:   Use a vertex group to allow per-vertex goal weights (multiplied by the *Default* goal).
user: Show practical ways to work with Renderer Settings in a Blender add-on or script – include code.

assistant: While shading nodes control the appearance, these settings control the quality and algorithms
that each renderer uses to render the material.

- [EEVEE specific settings](../eevee/material_settings.html)
- [Cycles specific settings](../cycles/material_settings.html)
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Pixelate Visual Effect.

Size X, Y
:   Horizontal and vertical size of the final pixels to apply.

Anti-aliasing
:   Applies an anti-aliasing effect to the resulting pixels.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: R
:   The radial distance from the origin in the X-Y plane.

Phi
:   The angular position around the Z axis.

Z
:   The vertical component of the input vector, corresponding directly to its Z coordinate.
user: Give a detailed overview of MaskStripModifier(StripModifier): syntax, arguments, return values, common patterns.

assistant: # MaskStripModifier(StripModifier)

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

*class* bpy.types.MaskStripModifier(*StripModifier*)
:   Mask modifier for sequence strip

    *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 Stencil Mask and how is it used in Blender Python scripting?

assistant: Specify an additional image texture that defines masked surfaces.
Masked surfaces can be defined with the Mask brush
and will not be affected by painting.

The mask can be deactivated by the checkbox in the header.

Stencil Image
:   Image used as a mask. See [Data-Block Menu](../../../interface/controls/templates/data_block.xhtml#ui-data-block).

UV Layer
:   Allows you to select the UV layer for the mask image.

Display Color
:   Mask color in the viewport. See [Color Picker](../../../interface/controls/templates/color_picker.xhtml#ui-color-picker).

    Invert
    :   Inverts the mask.
user: What is ObjectDisplay(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ObjectDisplay(bpy_struct)

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

*class* bpy.types.ObjectDisplay(*bpy_struct*)
:   Object display settings for 3D viewport

    show_shadows
    :   Object cast shadows in the 3D viewport

        Type:
        :   boolean, default True

    *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 Property Weights in complete detail according to the official Blender documentation.

assistant: # Property Weights

This panel is used to constrain certain cloth properties to a certain vertex group.
The properties that they control can be found in a combination of the *Physical Properties* and *Shape* panels.

Structural Group
:   Defines a vertex group to control over structural stiffness.

Max Tension
:   Maximum tension stiffness value.

Max Compression
:   Maximum Compression stiffness value.

Shear Group
:   Vertex group for fine control over shear stiffness.

Max Shearing
:   Maximum shear scaling value.

Bending Group
:   Vertex group for fine control over bending stiffness.

Max Bending
:   Maximum bending stiffness value.

Shrinking Group
:   Vertex group for shrinking cloth.

Max Shrinking
:   Max amount to shrink cloth by, specifying a negative value controls the max amount for the cloth to grow.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   The image socket can be used to connect to the Group Input node.
    If this is not connected the image can be opened or selected from the node.

Vector
:   Texture coordinate for texture look-up. If this socket is left unconnected,
    the Position attribute is used.

Frame
:   If the Image supports animation, the frame can be set here.
    This can be keyframed so that the image changes between frames.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Curve
:   Standard geometry input, containing curves.

Selection
:   Whether or not to change the value on each curve.

Mode
:   The method for evaluation of the curve’s normals

    Minimum Twist:
    :   The final normals are calculated to have the smallest twist around
        the curve tangent across the whole curve.

    Z-Up:
    :   The final normals are calculated so that they are perpendicular to the Z axis and the tangent.
        If a series of points is vertical, the X axis is used.

    Free:
    :   Use the stored custom normal attribute (`custom_normal`) as the final normals.

        This mode adds a *Normal* input that can be used to set the value of the custom normal.

Normal Free
:   Input for the custom normal attribute (`custom_normal`) when using *Free* mode.
user: How do I use Python Options in Blender? Include parameters, examples, warnings and best practices.

assistant: `-y`, `--enable-autoexec`
:   Enable automatic Python script execution.

`-Y`, `--disable-autoexec`
:   Disable automatic Python script execution (Python-drivers & startup scripts), (default).

`-P`, `--python` `<filepath>`
:   Run the given Python script file.

`--python-text` `<name>`
:   Run the given Python script text block.

`--python-expr` `<expression>`
:   Run the given expression as a Python script.

`--python-console`
:   Run Blender with an interactive console.

`--python-exit-code` `<code>`
:   Set the exit-code in [0..255] to exit if a Python exception is raised
    (only for scripts executed from the command line), zero disables.

`--python-use-system-env`
:   Allow Python to use system environment variables such as `PYTHONPATH` and the user site-packages directory.

`--addons` `<addon(s)>`
:   Comma separated list (no spaces) of add-ons to enable in addition to any default add-ons.
user: Explain Smooth Corrective Modifier in complete detail according to the official Blender documentation.

assistant: # Smooth Corrective Modifier

The *Smooth Corrective* modifier is used to reduce highly distorted areas of a mesh by smoothing the deformations.

This is typically useful *after* an [Armature modifier](armature.xhtml),
where distortion around joints may be hard to avoid, even with careful weight painting.

To use this modifier effectively, it is important to understand the basics of how it works.

Rest State
:   Used as a reference to detect highly distorted areas.
    The original vertex locations are used by default.

Smoothing
:   Many options for this modifier relate to smoothing which is used internally
    to correct the distorted regions.
user: Explain Armature Modifier in complete detail according to the official Blender documentation.

assistant: # Armature Modifier

The *Armature* modifier is used for building skeletal systems (rigs) for animating
the poses of characters and anything else which needs to be posed.

By adding an armature system to an object,
that object can be deformed accurately so that geometry does not have to be animated by hand.
user: Provide the full official documentation entry for Dependency graph: bpy.data.meshes.new_from_object(), preserving all code examples.

assistant: Function to copy a new mesh from any object with geometry. The mesh is added to the main
database and can be referenced by objects. Typically used by tools that create new objects
or apply modifiers.

When is used on original object, the result mesh is calculated from the object without taking
animation or modifiers into account:

- For meshes this is similar to duplicating the source mesh.
- For curves this disables own modifiers, and modifiers of objects used as bevel and taper.
- For meta-balls this produces an empty mesh since polygonization is done as a modifier evaluation.

When is used on evaluated object all modifiers are taken into account.

All the references (such as materials) are re-mapped to original. This ensures validity and
consistency of the main database.

```
import bpy

class OBJECT_OT_mesh_from_object(bpy.types.Operator):
    """Convert selected object to mesh and show number of vertices"""
    bl_label = "DEG Mesh From Object"
    bl_idname = "object.mesh_from_object"

    def execute(self, context):
        # Access input original object.
        obj = context.object
        if obj is None:
            self.report({'INFO'}, "No active mesh object to convert to mesh")
            return {'CANCELLED'}
        # Avoid annoying None checks later on.
        if obj.type not in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META'}:
            self.report({'INFO'}, "Object cannot be converted to mesh")
            return {'CANCELLED'}
        depsgraph = context.evaluated_depsgraph_get()
        object_eval = obj.evaluated_get(depsgraph)
        mesh_from_eval = bpy.data.meshes.new_from_object(object_eval)
        self.report({'INFO'}, f"{len(mesh_from_eval.vertices)} in new mesh, and is ready for use!")
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_mesh_from_object)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_mesh_from_object)

if __name__ == "__main__":
    register()
```
user: Give a detailed overview of Common Problems: syntax, arguments, return values, common patterns.

assistant: ### Unsupported Graphics Driver Error

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

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

### Crash on Startup

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

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

### Poor Performance

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

### Render Errors

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

### Wrong Selection in 3D Viewport

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

### Virtual Machines

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

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

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.