PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image
:   Standard color input.

Size
:   Controls the size of the smoothing neighborhood. Large values may introduce
    artifacts for highly detailed areas. For the anisotropic method, the larger
    the size, the slower the filter.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_filter_kuwahara-node_original.webp   Original. | ../../../_images/compositing_types_filter_kuwahara-node_size3.webp   Size: 3. |
    | ../../../_images/compositing_types_filter_kuwahara-node_size6.webp   Size: 6. | ../../../_images/compositing_types_filter_kuwahara-node_size9.webp   Size: 9. |

Type
:   Classic:
    :   A simple smoothing method that averages the local square
        neighborhood of the image while preserving edges. Produces blocky results
        due to the square neighborhood and provides no tuning parameters, but is
        faster to compute.

    Anisotropic:
    :   A complex smoothing method that averages the local
        neighborhood of the image in the direction of the flow of the edges,
        thus preserving the edges in the output. Produces painterly-like results
        and provides multiple turning parameters, while being slower to compute.

Uniformity
:   Controls the uniformity of the directions of the edges of the image. Non
    uniform directions are nearly never desirable, so this should typically be
    increased until the user notices the result is no longer changing in a
    significant way. Further increases would produces worst results and increase
    compute time.

Sharpness
:   Controls the sharpness of the edges of the image.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_filter_kuwahara-node_original.webp   Original. | ../../../_images/compositing_types_filter_kuwahara-node_sharpness0.webp   Sharpness: 0. |
    | ../../../_images/compositing_types_filter_kuwahara-node_sharpness05.webp   Sharpness: 0.5. | ../../../_images/compositing_types_filter_kuwahara-node_sharpness1.webp   Sharpness: 1. |

Eccentricity
:   Controls how thin and directional the filter is. Low eccentricity corresponds
    to circular omnidirectional features while high eccentricity corresponds to
    thin directional features.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_filter_kuwahara-node_original.webp   Original. | ../../../_images/compositing_types_filter_kuwahara-node_eccentricity0.webp   Eccentricity: 0. |
    | ../../../_images/compositing_types_filter_kuwahara-node_eccentricity1.webp   Eccentricity: 1. | ../../../_images/compositing_types_filter_kuwahara-node_eccentricity2.webp   Eccentricity: 2. |

High Precision Classic
:   Uses a more precise but slower method. Use if the output contains undesirable noise.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`BoidSettings.active_boid_state`](bpy.types.BoidSettings.html#bpy.types.BoidSettings.active_boid_state "bpy.types.BoidSettings.active_boid_state") - [`BoidState.active_boid_rule`](bpy.types.BoidState.html#bpy.types.BoidState.active_boid_rule "bpy.types.BoidState.active_boid_rule") | - [`BoidState.rules`](bpy.types.BoidState.html#bpy.types.BoidState.rules "bpy.types.BoidState.rules") |
user: What is Evaluate Closure and how is it used in Blender Python scripting?

assistant: # Evaluate Closure

[image reference removed]

The *Evaluate Closure* node executes a connected [Closure Zone](closure.xhtml).
It acts as the *call site* of the closure, running its internal node graph and returning the resulting values.

Closures enable dynamic and customizable node groups by allowing users to pass procedural logic into another node tree.
When the *Evaluate Closure* node runs, the connected closure is evaluated within the current context, matching its input
and output sockets by name.

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: How do I use Tooltips in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Tooltip of the Renderer selector in the Info Editor.

After hovering the mouse cursor over a button or setting for a few moments, a tooltip will appear.

### Elements

The context-sensitive tooltip might contain some of these elements:

Short Description
:   Related details depending on the control.

Shortcut
:   A keyboard or mouse shortcut associated to the tool.

Value
:   The value of the property.

    Hovering over a color property will display a large swatch preview of the color and the color’s hexadecimal, RGBA,
    and HSVA values.

    [image reference removed]

    Tooltip showing color information.

Library
:   Source file of the active object. See also [Linked Libraries](../files/linked_libraries/index.xhtml).

Disabled (red)
:   The reason why the value is not editable.

Python
:   When [Python Tooltips](../editors/preferences/interface.xhtml#bpy-types-preferencesview-show-tooltips-python) are enabled, a Python expression is
    displayed for [scripting](../advanced/scripting/index.xhtml#scripting-index) (usually an operator or property).
user: Show practical ways to work with DisplaySafeAreas(bpy_struct) in a Blender add-on or script – include code.

assistant: # DisplaySafeAreas(bpy_struct)

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

*class* bpy.types.DisplaySafeAreas(*bpy_struct*)
:   Safe areas used in 3D view and the sequencer

    action
    :   Safe area for general elements

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.035, 0.035)

    action_center
    :   Safe area for general elements in a different aspect ratio

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.15, 0.05)

    title
    :   Safe area for text and graphics

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.1, 0.05)

    title_center
    :   Safe area for text and graphics in a different aspect ratio

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.175, 0.05)

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

assistant: Geometry
:   The input geometry containing the hair curves to be blended.

Factor
:   Controls the overall strength of the blending effect.
    A value of 0.0 applies no blending, while 1.0 fully averages the selected curves.

Blend Radius
:   Defines the distance used to find neighboring curves that influence the blend.

Blend Neighbors
:   Limits the number of neighboring curves considered during the blending process.
    Increasing this value can result in smoother results but slower performance.

Preserve Length
:   When enabled, the length of each curve is maintained during blending.
    When disabled, curves may stretch or compress as a result of the averaging.
user: How do I use GeometryNodeImportSTL(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeImportSTL(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.GeometryNodeImportSTL(*GeometryNode*)
:   Import a mesh from an STL file

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

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field that is true for parts of the geometry to be deleted.

Amount
:   Field indicating how many times each input element should be duplicated.
    If the value is zero for an element, it will not be included in the output at all.
user: Explain NodeSocketVectorPercentage2D(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketVectorPercentage2D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorPercentage2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [-inf, inf], default (0.0, 0.0)

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Drivers in Blender? Include parameters, examples, warnings and best practices.

assistant: 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.

# Drivers

Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`ChannelDriverVariables.new`](bpy.types.ChannelDriverVariables.html#bpy.types.ChannelDriverVariables.new "bpy.types.ChannelDriverVariables.new") - [`ChannelDriverVariables.remove`](bpy.types.ChannelDriverVariables.html#bpy.types.ChannelDriverVariables.remove "bpy.types.ChannelDriverVariables.remove") | - [`Driver.variables`](bpy.types.Driver.html#bpy.types.Driver.variables "bpy.types.Driver.variables") |
user: How do I use Extending Menus in Blender? Include parameters, examples, warnings and best practices.

assistant: When creating menus for add-ons you can’t reference menus
in Blender’s default scripts.
Instead, the add-on can add menu items to existing menus.

The function menu_draw acts like [`Menu.draw`](#bpy.types.Menu.draw "bpy.types.Menu.draw").

```
import bpy

def menu_draw(self, context):
    self.layout.operator("wm.save_homefile")

bpy.types.TOPBAR_MT_file.append(menu_draw)
```
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Mode
:   The color model to output.

    RGB:
    :   Split the input image into it’s three outputs: Red, Green, and Blue color channels.

    HSV:
    :   Split the input image into it’s three outputs: Hue, Saturation, and Value color channels.

    HSL:
    :   Split the input image into it’s three outputs: Hue, Saturation, and Lightness color channels.

    YCbCrA:
    :   > Split the input image into it’s three outputs:
        > Luminance, Chrominance Blue, and Chrominance Red color channels.

        Color Space
        :   ITU 601, ITU 709, JPEG

    YUV:
    :   Split the input image into it’s three outputs:
        Luminance, U chrominance, and V chrominance color channels.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Context.window`](bpy.types.Context.html#bpy.types.Context.window "bpy.types.Context.window") - [`Window.parent`](#bpy.types.Window.parent "bpy.types.Window.parent") | - [`WindowManager.event_timer_add`](bpy.types.WindowManager.html#bpy.types.WindowManager.event_timer_add "bpy.types.WindowManager.event_timer_add") - [`WindowManager.windows`](bpy.types.WindowManager.html#bpy.types.WindowManager.windows "bpy.types.WindowManager.windows") |
user: Provide the full official documentation entry for Rip Vertices and Fill, preserving all code examples.

assistant: # Rip Vertices and Fill

Rip fill works the same as the Rip tool above, but instead of leaving a hole,
it fills in the gap with geometry.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-before.png   Edges selected. | ../../../../_images/modeling_meshes_editing_vertex_rip-vertices-fill_result.png   Result of rip fill. |
user: Show practical ways to work with Make Parent in a Blender add-on or script – include code.

assistant: To parent objects, select at least two objects
(select the child objects first, and select the parent object last),
and press `Ctrl`-`P`. The *Set Parent To* menu will pop up allowing
you to select from one of several possible different parenting types.
Selecting one of the entries in *Set Parent To* confirms,
and the child/children to parent relationship is created.
The selected objects will have their ‘parent’ set to the [active object](../selecting.xhtml#object-active),
and as a result will be ‘siblings’.

The *Set Parent To* pop-up menu is context-sensitive, which means
the number of entries it displays can change depending on what objects are selected
when the `Ctrl`-`P` shortcut is used.

Moving, rotating or scaling the parent will also usually transform the child/children.
Yet transforming the child/children of the parent will not affect the parent.
In other words, the direction of influence is from parent to child and not child to parent.

Type
:   Blender supports many different types of parenting, listed below.
    Besides parenting the selected objects, some types add a Modifier or Constraint to the child objects,
    with the parent as the target object or activates a parent property i.e. *Follow Path*.

    - Object
    - [Armature Deform](../../../animation/armatures/skinning/parenting.xhtml)
    - Bone
    - [Curve Deform](../../../modeling/modifiers/deform/curve.xhtml)
    - [Follow Path](../../../modeling/curves/properties/path_animation.xhtml#curve-path-animation)
    - [Path Constraint](../../../animation/constraints/relationship/follow_path.xhtml)
    - [Lattice Deform](../../../modeling/modifiers/deform/lattice.xhtml)
    - [Vertex](../../../modeling/meshes/editing/vertex/make_vertex_parent.xhtml)
    - [Vertex (Triangle)](../../../modeling/meshes/editing/vertex/make_vertex_parent.xhtml)

Keep Transform
:   The object’s current world transform (so its absolute location, rotation and scale in the world) is computed.
    The new parent is set, and then the *Parent Inverse* matrix is computed such that after setting
    the new parent the object is still at its previous world transform.

### Parent Inverse

Blender can assign a parent without moving the child object.
This is achieved via a hidden matrix called the *Parent Inverse* matrix,
which sits between the [transform](../../../glossary/index.xhtml#term-Transform) of the parent and the child.

When objects are parented with `Ctrl`-`P`, Parent Inverse matrix is updated.
Depending on the choice in the Set Parent menu, the object’s local location,
rotation, and scale are also updated. For more details, see [Object Parent](#object-parenting).

The Parent Inverse matrix can be cleared by using [Clear Parent Inverse](#bpy-ops-object-parent-clear).
user: Show practical ways to work with Histogram in a Blender add-on or script – include code.

assistant: Shows three overlapping graphs, one for each color channel. Within each graph:

- The X axis corresponds to color intensity, going from 0 on the left (black)
  to 1 on the right (fully red/green/blue).
- The Y axis corresponds to number of pixels.

Use this mode to balance out the tonal range in an image.
A well-balanced image should have nice and smooth distribution of color values.

[image reference removed]

Example image.

[image reference removed]

Corresponding Histogram.
user: Provide the full official documentation entry for Gradient (Radial), preserving all code examples.

assistant: Applies a radial weight gradient;
this is useful at times when painting gradual changes in weight becomes difficult.
Blends the weights of selected vertices with unselected vertices.

Weight
:   The gradient starts at the current selected weight value, blending out to nothing.

Strength
:   Lower values can be used so the gradient mixes in with the existing weights (just like with the brush).

Type
:   The shape of the gradient.

    Linear:
    :   Create gradient that forms a straight line.

    Radial:
    :   Create gradient that forms a circle.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

UI for a Harmonic force field.

Rest Length
:   Controls the rest length of the harmonic force.

Multiple Springs
:   Causes every point to be affected by multiple springs.

Normally every particle of the field system influences every particle of the target system.
Not with *Harmonic*! Here every target particle is assigned to a field particle.
So particles will move to the place of other particles, thus forming shapes.
user: How do I use Volumes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Volumes

Volume rendering is used to render various effects that cannot be represented by hard surfaces alone.

- Smoke, fire or clouds are set up using a volume object or fluid simulation,
  with only a volume shader.
- Meshes can also be used to create such shapes by removing the default surface shader
  and using a volume shader with the mesh shape defining the volume bounds
  and textures defining the volume density.
- Mist is created with a volume shader for the world,
  or with a large mesh object encompassing the scene.
- Absorption in glass is simulated by combining a glass surface shader with refraction
  and a volume absorption shader for the interior of the object.
user: Provide the full official documentation entry for Thickness, preserving all code examples.

assistant: Used to approximate the inner geometry structure of the object without heavy computation.
This is currently used for [Subsurface Scattering](../shader_nodes/shader/sss.xhtml),
[Translucent BSDF](../shader_nodes/shader/translucent.xhtml),
[Refraction BSDF](../shader_nodes/shader/refraction.xhtml), and the nodes containing these effects.

If no value is plugged into the output node,
a default thickness based on the smallest dimension of the object is used.
If a value is connected it will be used as object space thickness (i.e. scaled by object transform).
A value of zero will disable the thickness approximation and treat the object as having only one interface.

This output is only used by the EEVEE render engine.
user: Show practical ways to work with ShaderNodePointInfo(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodePointInfo(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.ShaderNodePointInfo(*ShaderNode*)
:   Retrieve information about points in a point cloud

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

assistant: # Introduction

*Sculpt Mode* is similar to *Edit Mode* in that it is used to alter the shape of a drawing,
but Sculpt Mode uses a very different workflow:
Instead of dealing with individual elements (points and edit lines),
an area of the model is altered using a brush.
In other words, instead of selecting a group of points,
Sculpt Mode manipulates the drawing in the brush region of influence.
user: Describe ImagePreview(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ImagePreview(bpy_struct)

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

*class* bpy.types.ImagePreview(*bpy_struct*)
:   Preview image and icon

    icon_id
    :   Unique integer identifying this preview as an icon (zero means invalid)

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    icon_pixels
    :   Icon pixels, as bytes (always 32-bit RGBA)

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

    icon_pixels_float
    :   Icon pixels components, as floats (RGBA concatenated values)

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

    icon_size
    :   Width and height in pixels

        Type:
        :   int array of 2 items in [-inf, inf], default (0, 0)

    image_pixels
    :   Image pixels, as bytes (always 32-bit RGBA)

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

    image_pixels_float
    :   Image pixels components, as floats (RGBA concatenated values)

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

    image_size
    :   Width and height in pixels

        Type:
        :   int array of 2 items in [-inf, inf], default (0, 0)

    is_icon_custom
    :   True if this preview icon has been modified by py script, and is no more auto-generated by Blender

        Type:
        :   boolean, default False

    is_image_custom
    :   True if this preview image has been modified by py script, and is no more auto-generated by Blender

        Type:
        :   boolean, default False

    reload()
    :   Reload the preview from its source path

    *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 ByteColorAttribute(Attribute) in complete detail according to the official Blender documentation.

assistant: # ByteColorAttribute(Attribute)

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

*class* bpy.types.ByteColorAttribute(*Attribute*)
:   Geometry attribute that stores RGBA colors as positive integer values using 8-bits per channel

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Color 1/2
:   Color of the bricks.

Mortar
:   The color of the area between bricks.

Scale
:   Overall texture scale.

Mortar Size
:   The size of the filling between the bricks known as “mortar”; 0 means no mortar.

Mortar Smooth
:   Blurs/softens the edge between the mortar and the bricks.
    This can be useful with a texture and displacement textures.

Bias
:   The color variation between *Color 1/2*.
    Values of -1 and 1 only use one of the two colors; values in between mix the colors.

Brick Width
:   The ratio of brick’s width relative to the texture scale.

Row Height
:   The ratio of brick’s row height relative to the texture scale.
user: Describe Select Linked from the Blender manual or Python API, including usage steps and snippets.

assistant: Press `Ctrl`-`L` to select all control points that are “linked to” (belong to the same
surface as) a control point that’s already selected.

Alternatively, press `L` to select the control point under the mouse cursor and all
control points that are linked to it.
user: What is Light Falloff Node and how is it used in Blender Python scripting?

assistant: # Light Falloff Node

Cycles Only

[image reference removed]

The *Light Falloff* node allows you to manipulate how light intensity decreases over distance.
In reality light will always fall off quadratically; however,
it can be useful to manipulate as a non-physically-based lighting trick.
Note that using Linear or Constant falloff may cause more light to be introduced with every global
illumination bounce, making the resulting image extremely bright if many bounces are used.
user: Explain Brush Automasking Flag Items in complete detail according to the official Blender documentation.

assistant: # Brush Automasking Flag Items

use_automasking_topology:
:   Topology.

    Affect only vertices connected to the active vertex under the brush.

use_automasking_face_sets:
:   Face Sets.

    Affect only vertices that share Face Sets with the active vertex.

use_automasking_boundary_edges:
:   Mesh Boundary Auto-Masking.

    Do not affect non manifold boundary edges.

use_automasking_boundary_face_sets:
:   Face Sets Boundary Automasking.

    Do not affect vertices that belong to a Face Set boundary.

use_automasking_cavity:
:   Cavity Mask.

    Do not affect vertices on peaks, based on the surface curvature.

use_automasking_cavity_inverted:
:   Inverted Cavity Mask.

    Do not affect vertices within crevices, based on the surface curvature.

use_automasking_custom_cavity_curve:
:   Custom Cavity Curve.

    Use custom curve.
user: Explain Kerning in complete detail according to the official Blender documentation.

assistant: Font kerning is the space between individual characters.

Decrease Kerning `Alt`-`Left`
:   Decreases the spacing between the characters on either side of the cursor.

Increase Kerning `Alt`-`Right`
:   Increase the spacing between the characters on either side of the cursor.

Reset Kerning
:   Sets the spacing between the characters on either side of the cursor to their initial value.
user: Show practical ways to work with Light in a Blender add-on or script – include code.

assistant: [Light settings](../lights/light_object.html) for all renderers.

### Beam Shape

Spread Area Lights
:   How wide the emitted light fans out controlling how diffused the area light is.
    Larger values create soft shadows while smaller values create sharper light
    simulating a [gridded softbox](https://en.wikipedia.org/wiki/Softbox).

    [image reference removed]

    Example of Spread at different angles.
user: Describe Relax Pose to Breakdown from the Blender manual or Python API, including usage steps and snippets.

assistant: Relax pose is somewhat related to the above topic, but it is only useful with keyframed bones.
When you edit such a bone (and hence take it “away” from its “keyed position”),
using this tool will progressively “bring it back” to its “keyed position”,
with smaller and smaller steps as it comes near it.
user: Give a detailed overview of NodeTreeInterfaceSocketFloatFrequency(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

assistant: # NodeTreeInterfaceSocketFloatFrequency(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.NodeTreeInterfaceSocketFloatFrequency(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Space Graph Mode Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Space Graph Mode Items

FCURVES:
:   Graph Editor.

    Edit animation/keyframes displayed as 2D curves.

DRIVERS:
:   Drivers.

    Define and edit drivers that link properties to custom functions or other data.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`PreferencesExtensions.repos`](bpy.types.PreferencesExtensions.html#bpy.types.PreferencesExtensions.repos "bpy.types.PreferencesExtensions.repos") - [`UserExtensionRepoCollection.new`](bpy.types.UserExtensionRepoCollection.html#bpy.types.UserExtensionRepoCollection.new "bpy.types.UserExtensionRepoCollection.new") | - [`UserExtensionRepoCollection.remove`](bpy.types.UserExtensionRepoCollection.html#bpy.types.UserExtensionRepoCollection.remove "bpy.types.UserExtensionRepoCollection.remove") |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Fluid physics share options with [Newtonian Physics](newtonian.html).
These are covered on that page.

### Fluid Properties

Stiffness
:   How incompressible the fluid is.

Viscosity
:   Linear viscosity. Use lower viscosity for thicker fluids.

Buoyancy
:   Artificial buoyancy force in negative gravity direction based on pressure differences inside the fluid.

### Advanced

Repulsion Factor
:   How strongly the fluid tries to keep from clustering (factor of stiffness).
    Checkbox sets repulsion as a factor of stiffness.

Stiff Viscosity
:   Creates viscosity for expanding fluid. Checkbox sets this to be a factor of normal viscosity.

Interaction Radius
:   Fluid’s interaction radius. Checkbox sets this to be a factor of 4 × *particle size*.

Rest Density
:   Density of fluid when at rest. Checkbox sets this to be a factor of default density.

### Springs

Force
:   Spring force.

Rest Length
:   Rest length of springs. Factor of particle radius. Checkbox sets this to be a factor of 2 × *particle size*.

Viscoelastic Springs
:   Use viscoelastic springs instead of Hooke’s springs.

Elastic Limit
:   How much the spring has to be stretched/compressed in order to change its rest length.

Plasticity
:   How much the spring rest length can change after the elastic limit is crossed.

Initial Rest Length
:   Use initial length as spring rest length instead of 2 × *particle size*.

Frames
:   Create springs for this number of frames since particle’s birth (0 is always).
user: What is Properties and how is it used in Blender Python scripting?

assistant: Mode
:   Evaluated:
    :   Creates points from the curve’s evaluated points based on
        the [resolution](../read/spline_resolution.xhtml) attribute
        for NURBS and Bézier splines. This mode will generally be the fastest,
        since the second step of sampling equal lengths is not necessary.

    Count:
    :   Sample each spline by evenly distributing the specified number of points.

    Length:
    :   Sample each spline by splitting it into segments with specified length.
        The length will be rounded down so that a whole number of samples will fit in
        each input spline. To counteract jumping when the length of the spline changes,
        the [Trim Curve Node](trim_curve.xhtml) can be used with
        a multiple of this length.
user: How do I use LineStyleThicknessModifier_Noise(LineStyleThicknessModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleThicknessModifier_Noise(LineStyleThicknessModifier)

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

*class* bpy.types.LineStyleThicknessModifier_Noise(*LineStyleThicknessModifier*)
:   Line thickness based on random noise

    amplitude
    :   Amplitude of the noise

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

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

        Type:
        :   float in [0, 1], default 0.0

    period
    :   Period of the noise

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

    seed
    :   Seed for the noise generation

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Thickness Modifier Type Items](bpy_types_enum_items/linestyle_thickness_modifier_type_items.html#rna-enum-linestyle-thickness-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    use_asymmetric
    :   Allow thickness to be assigned asymmetrically

        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.LineStyleThicknessModifier_Noise.type "bpy.types.LineStyleThicknessModifier_Noise.type")
user: How do I use Tool Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Threshold
:   How much changes in color affect the mask generation. A smaller threshold includes fewer similar colors.
    A larger threshold includes much more similar colors.

Contiguous
:   Mask only contiguous color areas. Colors that don’t touch the one that you click on will not be masked.

Invert
:   Invert the generated mask.

Preserve Previous Mask
:   Preserve previous mask and add or subtract the new one generated by the colors.
user: Show practical ways to work with Common Editor Keys in a Blender add-on or script – include code.

assistant: These keys are shared across editors such as the 3D Viewport, UV and Graph editor.

|  |  |
| --- | --- |
| `A` | Select all. |
| `Alt`-`A` /  Double-tap `A` | Select none. |
| `Ctrl`-`I` | Invert selection. |
| `H` | Hide selected items. |
| `Shift`-`H` | Hide unselected items. |
| `Alt`-`H` | Reveal hidden items. |
| `T` | Toggle Toolbar. |
| `N` | Toggle Sidebar. |
user: How do I use GeometryNodeTool3DCursor(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeTool3DCursor(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.GeometryNodeTool3DCursor(*GeometryNode*)
:   The scene’s 3D cursor location and rotation

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

assistant: Resolution
:   Number of edges on the circle.

Radius
:   The radius of the circle.

Point 1, Point 2, Point 3
:   The three points on the circle.
    The order of the points determines the direction (clockwise or counterclockwise) of the circle.
user: Describe ShapeKeyPoint(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShapeKeyPoint(bpy_struct)

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

*class* bpy.types.ShapeKeyPoint(*bpy_struct*)
:   Point in a shape key

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Select Menu and how is it used in Blender Python scripting?

assistant: All `A`
:   Select all.

None `Alt`-`A`
:   Select none.

Invert `Ctrl`-`I`
:   Selects all the geometry that is not selected, and deselect currently selected components.

---

[Box Select](../../../interface/selecting.xhtml#tool-select-box) `B`
:   Interactive box selection.

[Circle Select](../../../interface/selecting.xhtml#tool-select-circle) `C`
:   Interactive circle selection.

[Lasso Select](../../../interface/selecting.xhtml#tool-select-lasso)
:   Interactive free-form selection.

---

Select Mirror `Shift`-`Ctrl`-`M`
:   Select mesh items at the mirrored location across the chosen axis.

[Select Random](random.xhtml#bpy-ops-mesh-select-random)
:   Selects a random group of vertices, edges, or faces, based on a percentage value.

[Checker Deselect](checker_deselect.xhtml#bpy-ops-mesh-select-nth)
:   Deselect alternate elements relative to the active item.

---

More/Less
:   More `Ctrl`-`NumpadPlus`
    :   Expands the selection to the adjacent elements of the selection type.

    Less `Ctrl`-`NumpadMinus`
    :   Contracts the selection from the adjacent elements of the selection type.

    Next Active `Shift`-`Ctrl`-`NumpadPlus`
    :   This uses selection history to select the next vertex, edge, or face based on surrounding topology.

    Previous Active `Shift`-`Ctrl`-`NumpadMinus`
    :   Select previous just removes the last selected element.

---

[Select Similar](similar.xhtml#bpy-ops-mesh-select-similar) `Shift`-`G`
:   Select elements similar to the current selection.

[Select All by Trait](all_by_trait.xhtml)
:   Select geometry by querying its characteristics.

Select Linked
:   [Select Linked](linked.xhtml#bpy-ops-mesh-select-linked)
    :   Selects all components that are connected to the current selection.

    [Shortest Path](linked.xhtml#bpy-ops-mesh-shortest-path-select)
    :   Path between two selected elements.

    Linked Flat Faces
    :   Select connected faces based on a threshold of the angle between them.
        This is useful for selecting faces that are planar.

Select Loops
:   [Edge Loops](loops.xhtml#bpy-ops-mesh-loop-multi-select)
    :   Select connected edges.

    [Face Loops](loops.xhtml#modeling-meshes-selecting-face-loops)
    :   Select connected faces.

    [Edge Rings](loops.xhtml#modeling-meshes-selecting-edge-rings)
    :   Select connected edge ring.

Sharp Edges
:   This tool selects all edges between two faces forming an angle greater than the angle value,
    where an increasing angle selects sharper edges.

Side of Active
:   Selects all vertices on the mesh in a single axis relative to the active vertex.
    In Vertex selection mode only.