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

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Euler`](mathutils.html#mathutils.Euler "mathutils.Euler") rotation of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

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

assistant: [image reference removed]

Socket Inspection.

Socket inspection shows information about the value in a socket during the last evaluation.
For primitive data types such as integers, vectors, and strings the actual value is shown.
For geometry sockets only some data about the geometry is stored, including the set of
data types the geometry contains, and a count of their elements.

Socket values are only logged from when the node tree was executed, so a node must be
connected to the *Group Output* to have a value for inspection. Values are not logged during
rendering, to improve performance.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: Fig. [Meta ball base.](#fig-meta-ball-base) shows the *base* meta labeled “B”.
The other two *Meta* objects are *children*. Children’s selection rings are always black,
while the group’s mesh is orange. Because the metas are grouped,
they form a unified mesh which can always be selected by selecting the mesh of any meta in the group.

[image reference removed]

Meta ball base.

For example, in Fig. [Meta ball base.](#fig-meta-ball-base), only the lower sphere (the parent) has been selected,
and you see that both the parent’s mesh *and* all of the children’s meshes are now highlighted.

[image reference removed]

Scaling the “base”.

The *base* meta object controls the *polygonalization* (mesh structure) for the group, and
as such, also controls the polygonalization for the children (non-base) metas.
If we transform the *base* meta, the children’s polygonalization changes.
However, if we transform the children, the polygonalization remains unchanged.
user: Give a detailed overview of Skin Mesh Data: syntax, arguments, return values, common patterns.

assistant: That modifier needs a set of specific data in the original mesh to work properly.
This data allows you to define the root vertices of each tree, which ones are loose,
and the size (radius) of the skin at each vertex. The radii of input vertices can be individually
scaled in Edit Mode with the [Skin Resize](../../meshes/editing/mesh/transform/skin_resize.xhtml).
user: Describe Hue/Saturation Tips from the Blender manual or Python API, including usage steps and snippets.

assistant: Some things to keep in mind that might help you use this node better:

Hues are laid out on a circle
:   If you apply a Hue offset of 1 (+180°) to a blue image, you get the diametrically opposite
    color, which is yellow. If you apply a Hue offset of 1 to that yellow image, you get blue again.

Grayscale images have no hue
:   Trying to change the Hue or Saturation of a grayscale image has no effect. You can only brighten
    or darken it by adjusting the Value. To add color, use the Mix node instead.

Changing the effect over time
:   The different values can be animated using a *Time Curve* node or by setting keyframes.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Offset
:   The relative offset of the next row of bricks.

Frequency
:   Offset every N rows. The brick pattern offset repeats every N rows.

Squash
:   Scales the bricks in every N rows by this amount.

Frequency
:   Squash every N rows.
user: What is – Wireframe and how is it used in Blender Python scripting?

assistant: Only displays the edges (wireframes) of the objects in the scene.

Wireframe Color
:   How wireframes are colored. This affects the Wireframe shading mode and overlay.

    Theme:
    :   Use the *Active Object*, *Wire*, or *Wire Edit* [theme color](../../preferences/themes.xhtml)
        based on the object’s current state.

    Object:
    :   Use the color from the object’s
        [Viewport Display](../../../render/workbench/display_settings.xhtml#properties-object-viewport-display) settings.

    Random:
    :   Each object gets displayed in a random color.

Background
:   How the background is displayed in the 3D Viewport.

    Theme:
    :   Use the background of the theme. This can be configured in the
        [Themes Preferences](../../preferences/themes.xhtml)
        under 3D Viewport ‣ Theme Space ‣ Gradient Colors.

    World:
    :   Use the color from the [World](../../../render/lights/world.xhtml)’s Viewport Display options.

    Custom:
    :   Select a custom color for the background of the 3D Viewport.

### Options

X-Ray `Alt`-`Z`
:   Make objects transparent, allowing you to see and select items that would otherwise be occluded.
    The slider controls object opacity.

Outline
:   Draw an outline around objects. The color of the outline can be adjusted.
user: Show practical ways to work with TextureNodeCombineColor(TextureNode) in a Blender add-on or script – include code.

assistant: # TextureNodeCombineColor(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.TextureNodeCombineColor(*TextureNode*)
:   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: What is NodeTreeInterfaceSocketVectorVelocity4D(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Shape

[image reference removed]

Shape panel.

Resolution Preview U/V
:   The density of the generated surface mesh in the 3D Viewport. The higher this number, the more vertices
    there will be and the smoother the surface will look.

Render U/V
:   The density of the generated surface mesh in the render. If a number is 0, the corresponding number
    from *Resolution Preview* will be used instead.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_surfaces_properties_shape_resolution-1x1-wire.png   Resolution 1×1. | ../../../_images/modeling_surfaces_properties_shape_resolution-3x3-wire.png   Resolution 3×3. |
user: Show practical ways to work with System Directories in a Blender add-on or script – include code.

assistant: System directories store files that come bundled with Blender and
are required for it to function. This includes scripts, presets, essential
assets and more.

### Linux

Archive downloaded from blender.org:

```
./5.0/
```

Linux distribution packages:

```
/usr/share/blender/5.0/
```

### macOS

```
./Blender.app/Contents/Resources/5.0/
```

### Windows

Zip file downloaded from blender.org:

```
./5.0/
```

Installer downloaded from blender.org:

```
%ProgramFiles%\Blender Foundation\Blender\5.0\
```

Microsoft Store installation:

```
%ProgramFiles%\WindowsApps\BlenderFoundation.Blender<HASH>\Blender\5.0\
```

### Environment Variables

`BLENDER_SYSTEM_SCRIPTS` and `BLENDER_SYSTEM_EXTENSIONS`
[environment variables](command_line/arguments.xhtml#command-line-args-environment-variables)
can be used to [bundle additional scripts and extensions](deploying_blender.xhtml#deploying-blender-bundling),
that are not part of the regular Blender installation.

Other `BLENDER_SYSTEM` environment variables can override other system paths,
though are not commonly used in practice.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to change the resolution value on each spline. True values mean the value will be changed,
    false values mean the resolution will remain the same.

Resolution
:   The number of evaluated points generated for each control point in NURBS and Bézier splines.
    It controls the accuracy of operations like trimming or sampling a curve.
    Higher resolutions are more accurate, but slower.
user: Provide the full official documentation entry for Sequencer Context, preserving all code examples.

assistant: bpy.context.edit_mask
:   Type:
    :   [`bpy.types.Mask`](bpy.types.Mask.html#bpy.types.Mask "bpy.types.Mask")

bpy.context.tool_settings
:   Type:
    :   [`bpy.types.ToolSettings`](bpy.types.ToolSettings.html#bpy.types.ToolSettings "bpy.types.ToolSettings")
user: Explain ShaderNodeBackground(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeBackground(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.ShaderNodeBackground(*ShaderNode*)
:   Add background light emission.
    Note: This node should only be used for the world surface output

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Attribute.name`](bpy.types.Attribute.html#bpy.types.Attribute.name "bpy.types.Attribute.name") - [`Attribute.data_type`](bpy.types.Attribute.html#bpy.types.Attribute.data_type "bpy.types.Attribute.data_type") - [`Attribute.storage_type`](bpy.types.Attribute.html#bpy.types.Attribute.storage_type "bpy.types.Attribute.storage_type") | - [`Attribute.domain`](bpy.types.Attribute.html#bpy.types.Attribute.domain "bpy.types.Attribute.domain") - [`Attribute.is_internal`](bpy.types.Attribute.html#bpy.types.Attribute.is_internal "bpy.types.Attribute.is_internal") - [`Attribute.is_required`](bpy.types.Attribute.html#bpy.types.Attribute.is_required "bpy.types.Attribute.is_required") |
user: Describe Mask Slice from the Blender manual or Python API, including usage steps and snippets.

assistant: Removes the masked vertices from the mesh.

Threshold
:   Minimum mask value to consider the vertex valid to extract a face from the original mesh.

Fill Holes
:   Fills concave holes with geometry that might have resulted from the *Mask Slice* operation.

Slice to New Object
:   Create a new object from the masked geometry.
user: Give a detailed overview of Images: syntax, arguments, return values, common patterns.

assistant: Use the figure directive for embedding images with captions:

```
.. figure:: /images/interface_splash_current.webp

   Splash screen of Blender.
```

### Screenshots Guidelines

To ensure consistency across screenshots:

1. Use Blender’s default theme and settings.
2. Zoom to the maximum level (`Ctrl`-`MMB` or `NumpadPlus`).
3. Zoom out exactly eight steps (`NumpadMinus`, pressed eight times).
4. Leave around a 30-pixel margin around the content, if applicable.

### File Naming

Follow these guidelines for naming image files:

- Use lowercase letters, no spaces, underscores between sections, and dashes within multi-word sections.
- Place images only in the `manual/images` directory (no subfolders).

Examples:

- `interface_splash_current.png`
- `modeling_meshes_edit-mode.png`

### Image Formats

- `.png`: For interface screenshots or solid-color images.
- `.jpg`: For photographic images or renders with high color variation.
- Avoid `.gif`; use embedded videos for animations instead.
user: What is Line Project and how is it used in Blender Python scripting?

assistant: # Line Project

This tool flattens the geometry along a plane determined by the camera view and a drawn line.
The region of the mesh being flattened is visualized by the side of the line that is shaded.

|  |  |
| --- | --- |
| ../../../_images/sculpt-paint_sculpting_tools_line-project_before.png   Before Line Project. | ../../../_images/sculpt-paint_sculpting_tools_line-project_after.png   After Line Project. |
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Blur Visual Effect.

Mode
:   Grayscale
    :   Converts to a grayscale image.

    Sepia
    :   Converts to a sepia tone image.

    Duotone
    :   Converts to a posterize image with high contrast and brightness.

        Low Color
        :   Primary color.

        High Color
        :   Secondary color.

    Transparent
    :   Add color transparency.

    Custom
    :   Allows to define a tint custom color.

        Color
        :   Sets the tint color.

Factor
:   Control the mix value.
user: How do I use MatCaps in Blender? Include parameters, examples, warnings and best practices.

assistant: This panel manages [MatCap](../../glossary/index.html#term-MatCap) image files
which can used to light the view when [MatCap](../../render/workbench/lighting.html#render-workbench-matcap) shading is enabled.

Two kinds of images are supported for MatCaps. Regular image files and
multilayered OpenEXR files. When using multilayered OpenEXR files,
the layer named “diffuse” will be used as a diffuse pass, the layer named “specular”
will be used as a specular pass. Regular images will be handled as “diffuse” and
will not support specular highlighting.

The diffuse pass is multiplied with the base color of the objects and the specular pass is added on top.
MatCaps, that only have a diffuse pass tend to look very metallic,
with a separate specular pass it is possible to simulate a wider variety of materials.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Metaball objects (short meta) are *implicit surfaces*,
meaning that they are *not explicitly* defined by vertices (as meshes are)
or control points (as surfaces are): they exist *procedurally*.
Meta objects are literally mathematical formulas that are calculated on-the-fly by Blender.

A very distinct visual characteristic of metas is that they are fluid *mercurial*,
or *clay-like* forms that have a “rounded” shape. Furthermore,
when two meta objects get close to one another, they begin to interact with one another.
They “blend” or “merge”, as water droplets do, especially in zero-g (which, by the way,
makes them very handy for modeling streams of water when you do not want to do a fluid simulation).
If they subsequently move away from one another, they restore their original shape.

Each of these is defined by its own underlying mathematical [structure](structure.html),
and you can at any time switch between them using the *Active Element* panel.

Typically *Meta* objects are used for special effects or as a basis for modeling.
For example, you could use a collection of metas to form the initial shape of your model and
then convert it to a mesh for further modeling or sculpting. Meta objects are also very efficient for ray tracing.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Size X
:   Side length of the plane in the X direction.

Size Y
:   Side length of the plane in the Y direction.

Vertices X
:   Number of vertices in the X direction.
    If this is smaller than two, no mesh is generated.

Vertices Y
:   Number of vertices in the Y direction.
    If this is smaller than two, no mesh is generated.
user: Provide the full official documentation entry for LineStyleGeometryModifier_GuidingLines(LineStyleGeometryModifier), preserving all code examples.

assistant: # LineStyleGeometryModifier_GuidingLines(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_GuidingLines(*LineStyleGeometryModifier*)
:   Modify the stroke geometry so that it corresponds to its main direction line

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    offset
    :   Displacement that is applied to the main direction line along its normal

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_GuidingLines.type "bpy.types.LineStyleGeometryModifier_GuidingLines.type")
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Normal Direction
:   To manually set a fixed normal direction vector.
    `LMB` click and drag on the sphere to set the direction of the normal.
    Holding `Ctrl` while dragging snaps to 45 degree rotation increments.
user: Provide the full official documentation entry for Data Properties, preserving all code examples.

assistant: # Data Properties

[image reference removed]

Grease Pencil Object Data.

Grease Pencil
:   The Grease Pencil [data-block menu](../../interface/controls/templates/data_block.html#ui-data-block) can be used to link the data between objects.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Selection
:   Faces to participate in the unwrap operation.
    UVs that are part of any other face will not be affected.

Seam
:   Edges to mark where the mesh is “cut” for the purposes of unwrapping.

Margin
:   The distance to leave between UV islands.

Fill Holes
:   Virtually fill holes in mesh before unwrapping, to better avoid overlaps and preserve symmetry.

Method
:   Angle Based:
    :   This method gives a good 2D representation of a mesh.

    Conformal:
    :   Uses LSCM (Least Squares Conformal Mapping). This usually gives a less accurate UV
        mapping than Angle Based, but works better for simpler objects.
user: Show practical ways to work with More in a Blender add-on or script – include code.

assistant: Nodes for geometric data, texture coordinates,
layering shaders and non-physically-based tricks can be found in:

- [Vector Nodes](utilities/vector/index.xhtml)
- [Color Nodes](color/index.xhtml)
- [Utilities Nodes](utilities/index.xhtml)
user: Show practical ways to work with To Sphere in a Blender add-on or script – include code.

assistant: # To Sphere

The *To Sphere* transformation will give the selection spherical qualities.
The Fig. [Monkey with increasing sphericity.](#fig-mesh-deform-to-sphere-monkey) below shows the results of applying
the *To Sphere* transformation to the monkey mesh.

[image reference removed]

Monkey with increasing sphericity.

The sequence above shows a monkey mesh with
a 0, 0.25 (25%), 0.5 (50%) and 1 (100%) To Sphere transform applied.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Creating an Alpha Mask

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

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

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

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

### Colorizing an Image

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

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

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.
user: What is Set Handle Type and how is it used in Blender Python scripting?

assistant: Sets the handle type for the points on the Bézier curve that are in the selection.

Type
:   The handle type to switch to.

    Auto:
    :   This handle has a completely automatic length and direction
        which is set by Blender to ensure the smoothest result.
        These handles convert to *Align* handles when moved.

    Vector:
    :   Both parts of a handle always point to the previous handle or the next handle which allows
        you to create curves or sections thereof made of straight lines or with sharp corners.
        Vector handles convert to *Free* handles when moved.

    Align:
    :   These handles always lie in a straight line,
        and give a continuous curve without sharp angles.

    Free:
    :   The handles are independent of each other.

    Toggle Free/Align:
    :   Replaces Free handles with Align, and all Align with Free handles.
user: Provide the full official documentation entry for LibraryWeakReference(bpy_struct), preserving all code examples.

assistant: # LibraryWeakReference(bpy_struct)

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

*class* bpy.types.LibraryWeakReference(*bpy_struct*)
:   Read-only external reference to a linked data-block and its library file

    filepath
    :   Path to the library .blend file

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

    id_name
    :   Full ID name in the library .blend file (including the two leading ‘id type’ chars)

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

assistant: |  |  |
| --- | --- |
| - [**Value**](glossary/index.html#term-Value) - [Version Number Guidelines](advanced/extensions/version_number_guidelines.html#index-0) - [**Vertex**](glossary/index.html#term-Vertex) - [**Vertex Group**](glossary/index.html#term-Vertex-Group) - [**Vertices**](glossary/index.html#term-Vertices) - [Video Sequencer Modifiers](video_editing/edit/montage/strip_modifiers.html#index-1)   - [Brightness/Contrast Modifier](video_editing/edit/montage/strip_modifiers.html#index-2)   - [Color Balance Modifier](video_editing/edit/montage/strip_modifiers.html#index-3)   - [Compositor Modifier](video_editing/edit/montage/strip_modifiers.html#index-4)   - [Curves Modifier](video_editing/edit/montage/strip_modifiers.html#index-5)   - [Hue Correct Modifier](video_editing/edit/montage/strip_modifiers.html#index-6)   - [Mask Modifier](video_editing/edit/montage/strip_modifiers.html#index-7)   - [Sound Equalizer Modifier](video_editing/edit/montage/strip_modifiers.html#index-10)   - [Tone Map Modifier](video_editing/edit/montage/strip_modifiers.html#index-8)   - [White Balance Modifier](video_editing/edit/montage/strip_modifiers.html#index-9) | - [**Voxel**](glossary/index.html#term-Voxel) |
user: What is Properties and how is it used in Blender Python scripting?

assistant: Directory
:   The base output directory.

File Name
:   The base name of the file.
    The final filename may also include frame numbers or layer names depending on the settings.

Media Type
:   Determines how multiple inputs are stored:

    Image:
    :   Saves each input as a separate image file.
        Each input can use its own image format settings.

    Multi-Layer EXR:
    :   Saves all inputs together in a single multi-layer OpenEXR file.

### Node Format

This panel controls file format and encoding options, depending on the *Media Type*:

- **Image**: Controls the default format and encoding for all outputs.
  To override settings for an individual output, enable *Override Node Format* in the *Images/Layers* panel.
  See [Saving Images](../../../files/media/image_formats.html#bpy-types-imageformatsettings) for details on supported formats and options.
- **Multi-Layer EXR**: See [OpenEXR](../../../files/media/image_formats.html#files-images-openexr) for EXR-specific settings.

### Images/Layers

Lists all input sockets of the node.
The name of each input socket is used to construct the final file name.

When saving individual images, each output can be renamed and will be written to disk
using either the global *Node Format* settings or its own overridden settings.
When using *Multi-Layer EXR*, each input is stored as a separate layer within the file.

Override Node Format
:   Allows the selected output to use a custom format instead of the global *Node Format*.

#### Item Format

When *Override Node Format* is enabled, this panel controls the format and encoding options
for the selected output image.
See [Saving Images](../../../files/media/image_formats.html#bpy-types-imageformatsettings) for details.

### Output Paths

Displays the final file path and extension for each input/layer, based on current settings.
This helps verify that outputs are named and organized correctly.
user: What is Bones Influence and how is it used in Blender Python scripting?

assistant: [image reference removed]

A bone in Envelope visualization, in Edit Mode.

Basically, a bone controls a geometry when vertices “follow” the bone. This is like how
the muscles and skin of your finger follow your finger-bone when you move a finger.

To do this, you have to define the strength of *influences* a bone has on a certain vertex.

The simplest way is to have each bone affecting those parts of the geometry that are within
a given range from it. This is called the *envelope technique*,
because each bone can control only the geometry “enveloped” by its own influence area.

If a bone is visualized as *Envelope*, in *Edit Mode* and in *Pose Mode*
you can see the area of influence, which depends on:

- The *distance* property and
- the root’s radius and the tip’s radius.

[[image reference removed]](../../../_images/animation_armatures_bones_structure_envelope-pose-mode.png)

Our armature in Envelope visualization, in Pose Mode.

All these influence parameters are further detailed
in the [skinning pages](../skinning/index.html).
user: Give a detailed overview of Resizing: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

You can resize areas by dragging their borders with `LMB`.
Move your mouse cursor over the border between two areas,
so that the cursor changes to a double-headed arrow, and then click and drag.
Hold `Ctrl` to snap the size of areas to convenient sizes.
user: How do I use Sampling in Blender? Include parameters, examples, warnings and best practices.

assistant: Interpolation
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

[image reference removed]

Cycles is Blender’s physically-based path tracer for production rendering.
It is designed to provide physically based results out-of-the-box,
with artistic control and flexible shading nodes for production needs.

To use Cycles, select it as the *Render Engine* in the Render properties.
For [GPU accelerated rendering](gpu_rendering.html),
enable compatible devices in Preferences ‣ System ‣ Cycles Render Devices.
user: How do I use Smooth Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Smooth Modifier

The *Smooth* Modifier changes the value of one or more stroke/points properties like:
location, strength, thickness or UV texture position
trying to maintain similar values that make the line fluid and smoother.
user: Show practical ways to work with Effector in a Blender add-on or script – include code.

assistant: # Effector

Effector objects are used to deflect fluids and influence the fluid flow. To define any mesh object
as an effector object, add fluid physics by clicking *Fluid* in Properties ‣ Physics.
Then select *Effector* as the fluid *Type*.
user: Provide the full official documentation entry for Known Limitations, preserving all code examples.

assistant: For the most part, linking data will work as expected.
However, there are some limitations to be aware of.

### Circular Dependencies

In general, dependencies should not go in both directions.
Attempting to link or append data which links back to the current file will likely result in missing links.

### Scene-Level Settings

Scene-level settings such as the [Rigid Body World](../../physics/rigid_body/world.xhtml) will not
be copied when linking objects. As an alternative, you can link the
entire scene and use it as a [Background Scene](../../scene_layout/scene/properties.xhtml#bpy-types-scene-background-set).

### Compression & Memory Use

Referencing [compressed](../blend/open_save.xhtml#files-blend-compress) blend-files may need a lot of
memory because they have to be loaded in their entirety, even if you only link/append
a small part of them. Once the data-blocks are loaded, however, memory usage is the same.
user: Show practical ways to work with Strokes in a Blender add-on or script – include code.

assistant: # Strokes

Strokes are the final rendered lines. Yet you can tweak them, for example,
by removing the ones longer/shorter than some threshold,
chaining lines into a single stroke or breaking a stroke into several ones based on angles,
dashed pattern, etc.

[image reference removed]

Line Style: Strokes.

Caps
:   You can choose between three types of line caps:

    Butt:
    :   Flat cap, exactly at the point the line ends.

    Round:
    :   A half circle centered on the end point of the line.

    Square:
    :   A square centered on the end point of the line
        (hence, like the circle, the drawn end of the line is slightly extended compared to its computed value).

    [image reference removed]

    Line caps example.
user: Give a detailed overview of Space Action Mode Items: syntax, arguments, return values, common patterns.

assistant: # Space Action Mode Items

DOPESHEET:
:   Dope Sheet.

    Edit all keyframes in scene.

TIMELINE:
:   Timeline.

    Simple timeline view with playback controls in the header, without channel list, side-panel, or footer.
user: Explain Object Data in complete detail according to the official Blender documentation.

assistant: # Object Data

These panels can be found in the *Data* tab of the [Properties Editor](../../../editors/properties_editor.html)
editor after selecting a mesh object.

Mesh data-block
:   The [Data-Block Menu](../../../interface/controls/templates/data_block.html#ui-data-block) at the top can be used to make the object point
    to different mesh [object data](../../../scene_layout/object/introduction.html).
user: What is Attribute Search and how is it used in Blender Python scripting?

assistant: [image reference removed]

Attribute Search.

The attribute search is shown when clicking on an attribute input in the modifier.
It contains a list of all the attributes that were available at that point in
the modifier or node execution.
user: How do I use NodeTreeInterfaceSocketVectorTranslation2D(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Dope Sheet View

[image reference removed]

Dope Sheet View.

The Dope Sheet View is used to visualize motion tracking data,
it is implemented as separate view of the Movie Clip editor just like the Graph View.

It displays channels for selected tracks and each channel visualizes tracked
segments of tracks as dark bars and keyframed positions of tracks as small diamonds.

The background is highlighted depending on the number of tracks in a frame.
This means that if for a frame (or sequence of frames) there are less than eight tracks,
the background will turn red;
if there are from eight to sixteen tracks, the background will be yellow.

This is only a visual feedback, which doesn’t mean that the camera motion will not
reconstruct with less than eight tracks. It only means that you should pay attention to those frames and
check if all possible good feature points are tracked there. Remember, if there are no good feature points in
the frame and there are less than 16 tracks in the frame, it doesn’t mean the solution won’t be accurate.
Rather, adding more tracks on bad feature points will reduce the accuracy of solution.