PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain FunctionNodeInputString(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeInputString(FunctionNode)

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

*class* bpy.types.FunctionNodeInputString(*FunctionNode*)
:   Provide a string value that can be connected to other nodes in the tree

    string
    :   Type:
        :   [string](#bpy.types.FunctionNodeInputString.string "bpy.types.FunctionNodeInputString.string"), default “”, (never None)

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

assistant: # SEQUENCER_FH_image_strip(FileHandler)

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: SMAA Threshold
:   Threshold for the edge detection algorithm used to correct aliasing for the final render,
    Higher values may result in loss of detail due to excessive blurring.

SSAA Samples
:   Number of samples used for super-sampling anti-aliasing in the final render.
    Higher values produce smoother lines but increase render time.

Motion Blur Steps
:   Controls accuracy of [motion blur](../../../glossary/index.xhtml#term-Motion-Blur), more steps result in longer render time.
    Only used when [Motion Blur](motion_blur.xhtml#bpy-types-rendersettings-use-motion-blur) is enabled.
    Set to 0 to disable motion blur for Grease Pencil objects.
user: How do I use Orientation in Blender? Include parameters, examples, warnings and best practices.

assistant: Scene orientation tools can be used for orienting object to bundles.

Floor
:   See [Set Origin](../editing/reconstruction.xhtml#bpy-ops-clip-set-origin).

Wall
:   See [Set Floor](../editing/reconstruction.xhtml#bpy-ops-clip-set-plane).

Set Origin
:   See [Set Floor](../editing/reconstruction.xhtml#bpy-ops-clip-set-plane).

Set X, Y Axis
:   See [Set X/Y Axis](../editing/reconstruction.xhtml#bpy-ops-clip-set-axis).

Set Scale
:   See [Set Scale](../editing/reconstruction.xhtml#bpy-ops-clip-set-scale).

Apply Scale
:   See [Apply Solution Scale](../editing/reconstruction.xhtml#bpy-ops-clip-apply-solution-scale).

Distance
:   Distance in active scene units which is used by Set/Apply scale.
user: Provide the full official documentation entry for GPENCIL_UL_annotation_layer(UIList), preserving all code examples.

assistant: # GPENCIL_UL_annotation_layer(UIList)

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

*class* bpy.types.GPENCIL_UL_annotation_layer(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

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

assistant: # Distribute Points on Faces

[image reference removed]

The *Distribute Points on Faces* node places points on the surface of the input geometry object.
Point, corner, and polygon attributes of the input geometry are transferred to the generated points.
That includes vertex weights and UV maps.
Additionally, the node has *Normal* and *Rotation* outputs.

The node also generates a stable ID, stored in the built-in `id` attribute, used as
a stable identifier for each point. When the mesh is deformed or the density changes
the values will be consistent for each remaining point. This attribute is used in
the [Random Value](../utilities/random_value.xhtml) and
[Instance on Points](../instances/instance_on_points.xhtml) nodes.
user: Describe Main Region from the Blender manual or Python API, including usage steps and snippets.

assistant: The editor displays a stack of [tracks](tracks.xhtml) which work like layers in an image editing
program. Higher tracks take precedence over lower ones, although you can also choose to blend them.

Each track can contain any number of [strips](strips.xhtml) – typically Action Strips,
which are instances of actions.

The top track highlighted in orange is special: this is the Action Track. Unlike the other tracks,
it doesn’t contain strips – instead, it contains the object’s *active action*,
which is where new keyframes are added to by default.

Editors like the [Dope Sheet Editor](../dope_sheet/introduction.xhtml)
normally only show the keyframes of this active action. If you want to edit another action,
you can select it in the NLA editor and press `Tab` to enter Tweak Mode.

[image reference removed]

Tweaking an action. Notice that it’s shown in both its original track and the Action Track.
The active action is temporarily hidden.
user: Show practical ways to work with Is UV Split Node in a Blender add-on or script – include code.

assistant: # Is UV Split Node

[image reference removed]

The *Is UV Split* node outputs a selection indicating which edges in a mesh are *UV splits*.
A UV split occurs when an edge connects two faces that use different UV coordinates along that edge,
causing a discontinuity in the UV map.

This node is useful for detecting UV seams, isolating edges used for UV islands, or
creating procedural operations that depend on UV boundaries.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

We have seen in [previous pages](../index.html) how to design an armature,
create chains of bones, etc.
Now, having a good rig is not the final goal, unless you want to produce a “Dance Macabre” animation,
you will likely want to put some flesh on your skeletons!
Surprisingly, “linking” an armature to the object(s)
it should transform and/or deform is called the “skinning” process…

[image reference removed]

The human mesh skinned on its armature.

In Blender, you have two main skinning types:

1. You can [Parent/Constrain Objects to Bones](../../../scene_layout/object/editing/parent.html) –
   then, when you transform the bones in *Pose Mode*, their “children” objects are also transformed,
   exactly as with a standard parent/children relationship…
   The “children” are **never** deformed when using this method.
2. You can [Use the Armature Modifier on entire Mesh](parenting.html),
   and then, some parts of this object to some bones inside this armature.
   This is the more complex and powerful method,
   and the only way to really deform the geometry of the object,
   i.e. to modify its vertices/control points relative positions.
user: What is Scene and how is it used in Blender Python scripting?

assistant: Camera
:   Used to select which camera is used as the active camera.
    You can also set the active camera in the 3D Viewport with `Ctrl`-`Numpad0`.

Background Scene
:   Allows you to use a scene as a background,
    this is typically useful when you want to focus on animating the foreground for example,
    without background elements getting in the way.

    This scene can have its own animation, physics simulations, etc,
    but you will have to select it from the *Scene* data-block menu, if you want to edit any of its contents.

    Background Scenes can themselves have a Background Scene (they’re recursively included).
    So you can always make additions to existing scenes by using them as a background
    to a newly created scene where your additions are made.

Active Clip
:   Selects a [Movie Clip](../../movie_clip/index.html) that can be used by
    [Motion Tracking Constraints](../../animation/constraints/motion_tracking/index.html) or a camera’s [Background Images](../../render/cameras.html#bpy-types-camerabackgroundimage).
user: Explain UDIMs in complete detail according to the official Blender documentation.

assistant: # UDIMs

Using UV maps can have one disadvantage, they consist of one texture for the entire mesh.
Most of the time this is sufficient but the disadvantage is that the texture is one resolution for the entire mesh.
This causes issues if you have a very large mesh with geometry of different importance.
When using a singular texture, the resolution might be too low to cover larger UV islands
while being inefficient for smaller, less important islands.

UDIM offers a solution to this by being able to spread UV islands across several different textures.
UDIM which stands for U DIMension is based on a tile system
where each tile is a different texture in the overall UDIM texture array.
Basically each tile consists of its own UV space (0-1, 1-2, 2-3) and have its own image assigned to that tile.
Tiles are managed in the [UDIM Tiles](#udim-tiles) panel where they can have a generated image assigned to them.
Generally, you create several textures of different resolutions;
for example, you may have a 4k resolution texture for the major details,
and 2k and/or 1k textures for less important details.

The UDIM array consists of one main tile, this tile is given the index number of `1001`.
The next tile that gets added will be `1002` and will be placed to the right of the main tile.
The overall UDIM array is ten tiles wide, so tiles `1001` through `1010` are created on the first row.
After ten tiles a new row of tiles is started above the main tile; so `1011` will be place directly above `1001`.
user: Explain Material Index Node in complete detail according to the official Blender documentation.

assistant: # Material Index Node

[image reference removed]

The *Material Index* node outputs which material in the list of materials of the geometry
each element corresponds to. Currently the node supports mesh data, where `material_index`
is a built-in attribute on faces.

The node to set this data is
the [Set Material Index](set_material_index.xhtml) node.
user: Explain Header in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Sort order of the channels.

Only Show Selected
:   Limits Dope Sheet channels to only information about selected tracks.

Display Hidden
:   Includes information from hidden tracks.

Dopesheet Sort Field
:   Sort order of the tracks.

    Name:
    :   Sort selected tracks in alphabetical order based on their names.

    Longest:
    :   Sort tracks by longest tracked segment length.

    Total:
    :   Sort tracks by overall amount of frames.

    Average Error:
    :   Sort tracks by their average reprojection error after solving camera or object motion.

    Start Frame:
    :   Sort channels by first frame number.

    End Frame:
    :   Sort channels by last frame number.

Invert
:   To change the sort order from ascending to descending.
user: Provide the full official documentation entry for Collection Exporters, preserving all code examples.

assistant: This exporter can be used as a collection exporter.
See [Collections](../../scene_layout/collections/collections.html) for more information about collections and their exporters.

Here are the options & specificity for collection export:

- Include part of options are not available for collection exporter (like every other exporter).
- Option to export at collection center (at center of mass of all root objects of the collection).
- Custom Properties of the collection are exported as Scene glTF extras.
user: What is Interpolate Sequence and how is it used in Blender Python scripting?

assistant: Interpolate strokes between the previous and next keyframe by adding *multiple* keyframes.
A breakdown keyframe will be added on every frame between the previous and next keyframe.

Step
:   Number of frames between generated interpolated frames.

Layer
:   Layers included in the interpolation.

Exclude Break Downs
:   Exclude existing Breakdowns keyframes as interpolation extremes.

Flip Mode
:   Invert destination stroke to match start and end with source stroke.

Smooth
:   Amount of smoothing to apply to interpolated strokes, to reduce jitter/noise.

Iterations
:   Number of times to smooth newly created strokes.

Type
:   Interpolation method to use the next time *Interpolate Sequence* is run.
user: Explain Add Marker in complete detail according to the official Blender documentation.

assistant: The simplest way to add a marker is to move to the frame where you would like it to appear,
and press `M`.

### Pose Markers

If [Show Pose Markers](#bpy-types-spacedopesheeteditor-show-pose-markers) is enabled, a pose marker is added.
user: What is Expand Face Set by Topology and how is it used in Blender Python scripting?

assistant: Expands a face set from the active vertex.
This operator uses the same internal operator as [Expand](#bpy-ops-sculpt-expand)
meaning all the hotkeys and functionality works the same as that tool,
with the gradient features as the exception.

### Usage

Saving Masks
:   Expanding Face Sets has all the same use cases as expanding masks.
    The advantage for this one is that they will be saved for repeated usage.
    Face sets can be filled any time with a mask,
    so assigning areas face sets will save you time.
    (And of course face sets can be used to
    [hide face sets](sculpt.xhtml))

Pivot Points for Pose Brush
:   When using the [Pose Brush](../brushes/pose.xhtml) it is most predictable when using it with
    Face Sets to define the face set boundaries as pivot point locations.
    Face Sets can be expanded from a point or from a boundary between hidden face sets
    to create them quickly.
    Alternatively [Grow/Shrink Face Sets](face_sets.xhtml#bpy-ops-sculpt-face-set-edit)
    or use the [Expand Active Face Set](#face-set-expand-active) to dynamically grow/shrink them.

Cloth Sculpting
:   Tools like the [Cloth Filter](../tools/cloth_filter.xhtml)
    and [Cloth Brush](../brushes/cloth.xhtml)
    work especially well when only simulating small areas at a time.
    Face Sets can very easily be created with Expand to assign areas of action.
user: How do I use Checker Deselect in Blender? Include parameters, examples, warnings and best practices.

assistant: # Checker Deselect

This tool applies an alternating selected/deselected checker pattern.
This only works if you already have more than one mesh element selected.

Changes the current selection so that only every Nth elements (vertices, edges or faces,
depending on the active selection mode) will remain selected, starting from the active one.

In case of islands of selected elements, this tool will affect
only the island of the active element (if there is one), or the island of the first element
in the order of internal storage (if there is no active element).

Deselected
:   The number of deselected elements in each pattern repetition.

Selected
:   The number of selected elements in each pattern repetition.

Offset
:   Offset from the starting point.
user: Provide the full official documentation entry for Simple Contribution, preserving all code examples.

assistant: The preferred way to contribute to the translation effort is via the
[web-based interface](https://translate.blender.org/projects/blender-manual/manual), currently hosted on Weblate.

Suggestions for translations can be contributed without logging in. They will be reviewed by the translation team
before being published.

Weblate also provides tools such as the
[glossary](https://translate.blender.org/projects/blender-manual/glossary/) to improve translation consistency.
user: Give a detailed overview of Sidebar: syntax, arguments, return values, common patterns.

assistant: In the Sidebar, you can define filters so that only the rows matching these filters
are displayed. Click *Add Row Filter* and set up the properties described below.

Enabled
:   Uncheck to temporarily disable the filter.

Column
:   The name of the column to filter on. If there is no column with the specified name,
    the filter will be grayed out and ignored.

    If you want to filter on an attribute from another domain, you can use the
    [Store Named Attribute Node](../modeling/geometry_nodes/attribute/store_named_attribute.xhtml) to create a copy
    that’s converted to the current domain, then filter on that.

Operation
:   For numerical columns, you can select one of the following comparison operators.
    Other columns only support *Equal To*.

    Equal To:
    :   Only display rows whose value for the column is equal to the filter value
        (within the specified threshold).

    Greater Than:
    :   Only display rows whose value for the column is greater than the filter value.

    Less Than:
    :   Only display rows whose value for the column is less than the filter value.

Value
:   The filter value to compare the row value to.

Threshold
:   How much the row’s value is allowed to deviate from the filter value before it is excluded.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Bokeh Type
:   The number of iris blades of the virtual camera’s diaphragm.

    Disk (to emulate a perfect circle), Triangle (3 blades), Square (4 blades),
    Pentagon (5 blades), Hexagon (6 blades), Heptagon (7 blades) or Octagon (8 blades).

Angle
:   This slider is deactivated, if the Bokeh Type is set to Disk.
    It can be used to add a rotation offset to the Bokeh shape.
    The value is the angle in degrees.

F-Stop
:   This option controls the amount of focal blur in the same way as a real camera.
    It simulates the aperture *f* of a real lens’ iris, without modifying the luminosity of the picture.
    The default value 128 is assumed to be infinity:
    everything is in perfect focus. Half the value will double the amount of blur.
    This slider is deactivated, if *No Z-buffer* is enabled.

Max Blur
:   This value limits the amount of blur by setting a maximum blur radius.
    Can be used to optimize the performance.
    The default value of 0 means no limit.

Scene
:   To select the linked scene.

No Z-buffer
:   Should be activated for a non Z-buffer in the Z input.
    No Z-buffer will be enabled automatically
    whenever a node that is not image based is connected to the Z input.

Z Scale
:   Only active when *No Z-buffer* is enabled. When *No Z-buffer* is used,
    the input is used directly to control the blur radius (similar to *F-Stop* when using the Z-buffer).
    This parameter can be used to scale the range of the Z input.
user: Describe FILEBROWSER_UL_dir(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FILEBROWSER_UL_dir(UIList)

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

*class* bpy.types.FILEBROWSER_UL_dir(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

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

assistant: # GeometryNodeMeshIcoSphere(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.GeometryNodeMeshIcoSphere(*GeometryNode*)
:   Generate a spherical mesh that consists of equally sized triangles

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

assistant: # GeometryNodeProximity(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.GeometryNodeProximity(*GeometryNode*)
:   Compute the closest location on the target geometry

    target_element
    :   Element of the target geometry to calculate the distance from

        - `POINTS`
          Points – Calculate the proximity to the target’s points (faster than the other modes).
        - `EDGES`
          Edges – Calculate the proximity to the target’s edges.
        - `FACES`
          Faces – Calculate the proximity to the target’s faces.

        Type:
        :   enum in [`'POINTS'`, `'EDGES'`, `'FACES'`], default `'FACES'`

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

assistant: |  |  |
| --- | --- |
| - [**Lattice**](glossary/index.xhtml#term-Lattice) - [Licenses](advanced/extensions/licenses.xhtml#index-0) | - [**Light Bounces**](glossary/index.xhtml#term-Light-Bounces) - [**Local Space**](glossary/index.xhtml#term-Local-Space) - [**Luminance**](glossary/index.xhtml#term-Luminance) |
user: What is ThemeSpaceGeneric(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ThemeSpaceGeneric(bpy_struct)

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

*class* bpy.types.ThemeSpaceGeneric(*bpy_struct*)
:   back
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

    header_text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    header_text_hi
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text_hi
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    title
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], 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 Offset Point in Curve Node and how is it used in Blender Python scripting?

assistant: # Offset Point in Curve Node

[image reference removed]

The *Offset Point in Curve* node retrieves other points in the same curve as
the input control point. This is like starting at a specific control point and
walking along neighboring points toward the start or end of the curve.

Conceptually the operation is similar to the
[Offset Corner in Face Node](../../mesh/topology/offset_corner_in_face.html),
but the point index doesn’t wrap around to the other end of the curve unless it is cyclic.
user: Explain Settings in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Canvas main panel.

Paint Surface
:   A [list](../../interface/controls/templates/list_view.html#ui-list-view) of Dynamic Paint surfaces.
    These surfaces are basically layers of paint, that work independently from each other.
    You can define individual settings for them and bake them separately.

    Is Active
    :   The checkbox toggles whether surface is active at all.
        If not selected no calculations are done.

Below you can set surface type and adjust quality and timing settings.

Format
:   Each surface has a certain format and type.
    Format determines how data is stored and outputted.

    Vertex:
    :   Dynamic Paint operates directly on mesh vertex data.
        Results are stored by point cache and can be displayed in viewports.
        However, using vertex level also requires a highly subdivided mesh to work.

    Image Sequences:
    :   Dynamic Paint generates UV wrapped image files of defined resolution as output.

        Resolution
        :   You can adjust the output image dimensions for the *Image Sequences* surface type.
            For example using 256 will lead to 256×256 image output.
            Doubling the resolution will likely quadruple the baking time and vice versa.

        Anti-Aliasing
        :   [Anti-Aliasing](../../glossary/index.html#term-Anti-Aliasing) to smooth paint edges using a 5× multisampling method.

Frame Start, End
:   Defines surface processing start and end frame.

Sub-Steps
:   Extra samples between frames. They are usually required when there is a very fast brush.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

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

assistant: ### Blur Alpha

[image reference removed]

An example of blurring the alpha channel.

In this first example, we take the Alpha channel and blur it,
and then combine it back with the colors. When placed in a scene,
the edges of it will blend in, instead of having a hard edge.
This is almost like [Anti-Aliasing](../../../glossary/index.xhtml#term-Anti-Aliasing) but in a three-dimensional sense.
Use this node setup, when adding CG elements to live action to remove any hard edges.
Animating this effect on a broader scale will make the object appear to “phase” in and out,
as an “out-of-phase” time-traveling sync effect.

### Increase Luminance

[image reference removed]

An example of the scaling the Luminance channel.

This example has a *Math (Multiply)* node increasing the luminance channel (Y)
of the image to make it brighter.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Color
:   RGB color interpolated from the attribute.

Vector
:   XYZ vector interpolated from the attribute.

Factor
:   Scalar value interpolated from the attribute.

Alpha
:   Alpha channel of the attribute, when available. If the attribute has no alpha channel, generally defaults to 1.
user: What is Snapping and how is it used in Blender Python scripting?

assistant: # Snapping

[image reference removed]

Snap menu.

Snapping lets you easily align objects and mesh elements to others.
It can be toggled by clicking  (Snap Off) /  (Snap On)
in the 3D Viewport’s header, or more temporarily by holding `Ctrl`.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_eevee_render-settings_motion-blur_1step-nofx.png   No motion blur. | ../../../_images/render_eevee_render-settings_motion-blur_1step-fx.png   Only post-process blur. |
| ../../../_images/render_eevee_render-settings_motion-blur_4step-nofx.png   4 time steps without post-process blur. | ../../../_images/render_eevee_render-settings_motion-blur_4step-fx.png   4 time steps with post-process blur. |
| ../../../_images/render_eevee_render-settings_motion-blur_32step-nofx.png   32 time steps without post-process blur. | ../../../_images/render_eevee_render-settings_motion-blur_32step-fx.png   32 time steps with post-process blur. |
user: Give a detailed overview of Gizmos: syntax, arguments, return values, common patterns.

assistant: The *Glare* node provides an interactive gizmo in the Node Editor.
To use it, enable [Active Node Gizmo](../../../editors/compositor.xhtml#bpy-types-spacenodeeditor-show-gizmo-active-node) and
select the *Glare* node.

For the *Sun Beams* type, a cross-shaped gizmo appears in the image preview to set the *Sun Position*.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Bricks 1, Bricks 2
:   Sets the color range of the bricks. Brick colors are chosen randomly between these two colors.

Mortar
:   Sets the mortar color, in between the bricks.

Thickness
:   Sets the thickness of the mortar.

Bias
:   The bias of randomly chosen colors,
    between (-1 to 1). -1 Makes all bricks Color 1, and a value of 1 makes them all Color 2.

Brick Width
:   Sets the horizontal size of all the bricks.

Row Height
:   Sets the vertical size of all the bricks.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field indicating which geometry elements to include.

Group ID
:   Integer field indicating which group each element belongs to. Elements with the
    same ID will be moved into the same output instance.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Seconds
:   Current scene time in seconds.

Frames
:   Current scene frame.
    As an input in geometry nodes, this output may also output non-round numbers,
    in order to support higher quality [motion blur](../../../../render/eevee/render_settings/motion_blur.xhtml).
user: Give a detailed overview of NodeTreeInterfaceSocketVectorDirection(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

assistant: # NodeTreeInterfaceSocketVectorDirection(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.NodeTreeInterfaceSocketVectorDirection(*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 3 items in [-inf, inf], default (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: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Smooth modifier.

Axis
:   Enable/disable the modifier in the X, Y and/or Z axes directions.

Factor
:   Controls the smoothing amount.
    Higher values will increase the effect.

    Values outside expected range (above 1.0 or below 0.0) will distort the mesh.

Repeat
:   The number of smoothing iterations,
    equivalent to executing the *Smooth* tool multiple times.

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.
    This allows for selective, real-time smoothing, by painting vertex weights.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.
user: Show practical ways to work with Object Type Items in a Blender add-on or script – include code.

assistant: # Object Type Items

MESH:
:   Mesh.

CURVE:
:   Curve.

SURFACE:
:   Surface.

META:
:   Metaball.

FONT:
:   Text.

CURVES:
:   Hair Curves.

POINTCLOUD:
:   Point Cloud.

VOLUME:
:   Volume.

GREASEPENCIL:
:   Grease Pencil.

---

ARMATURE:
:   Armature.

LATTICE:
:   Lattice.

---

EMPTY:
:   Empty.

---

LIGHT:
:   Light.

LIGHT_PROBE:
:   Light Probe.

---

CAMERA:
:   Camera.

---

SPEAKER:
:   Speaker.
user: Provide the full official documentation entry for GeometryNodeInputMeshEdgeNeighbors(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInputMeshEdgeNeighbors(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.GeometryNodeInputMeshEdgeNeighbors(*GeometryNode*)
:   Retrieve the number of faces that use each edge as one of their sides

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: - Nodes can be added to a frame by dragging them inside it.
- Moving the frame also moves all contained nodes.
- Frames can be resized by dragging the corners or edges.
- The frame can display a custom label, useful for naming sections of your node setup.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

The 2D video stabilization is a feature built on top of Blender’s image feature tracking abilities:
You can use some tracking points to remove shakiness, bumps and jerks from video footage.
Typically, image stabilization is part of a 2D workflow to prepare and improve footage
prior to further processing or modeling steps. This page helps to understand how it works,
introduces related terms and concepts, describes the available interface controls in detail
and finally gives some hints about usage in practice.

Typical usage scenarios of the stabilizer:

- Fix minor deficiencies (shaky tripod, jerk in camera movement).
- “Poor man’s steadycam” (when a real steadycam was not available, affordable or applicable).
- As a preparation for masking, matching and rotoscoping.

It is not uncommon for 2D stabilization to have to deal with somewhat imperfect and flawed footage.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard geometry input containing a mesh.

Material
:   The material to apply to the geometry.

Selection
:   Whether to change the material of each face.
    True values mean the material will be changed, false values mean it will remain the same.

    Note, volumes and point clouds only support a single material,
    in these cases a field input will be ignored.
user: Describe Painting from the Blender manual or Python API, including usage steps and snippets.

assistant: # Painting

Sculpt Mode also allows painting your geometry via
[Color Attributes](../../../modeling/meshes/properties/object_data.html#modeling-meshes-properties-object-data-color-attributes) such as Vertex Colors. This ensures that the most
common actions related to the sculpting workflow are contained in the same mode, to avoid unnecessary mode switching.

[image reference removed]

Other sculpt mode features such as face sets, masking and filters can also be used with painting tools.

The painting functionality in Sculpt Mode is limited to a
[Paint](../brushes/paint.html)
and [Smear](../brushes/smear.html) brush,
as well as a [Color Filter](../tools/color_filter.html)
and [Mask by Color](../tools/mask_by_color.html) tool.

Just like any other brush, `Shift` can be used to smooth.
In the case of painting brushes it will blur the colors within the brush radius instead.
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 trim.

Scale Uniform
:   When enabled, each curve is scaled uniformly to reach the target length.
    When disabled, trimming is applied progressively from root to tip.

Length Factor
:   Multiplies the original curve length by this factor.
    A value of 1.0 keeps the hair at its original length, while 0.5 halves it.

Replace Length
:   When enabled, the *Length* input fully replaces the original curve length
    instead of scaling it by the *Length Factor*.

Length
:   The target length for the operation.
    Used when *Replace Length* is enabled.

Mask
:   A per-curve mask that modulates the overall trimming effect.
    A value of 0.0 disables trimming for that curve, while 1.0 applies the full effect.

Random Offset
:   Adds random variation to the trimmed length of each curve,
    creating more natural-looking hair variation.

Pin at Parameter
:   Specifies a parameter along each curve to act as a pivot or anchor point during trimming.
    The trimming operation is performed relative to this point.

Seed
:   Sets the random seed used for the random offset.
    Changing this value produces different trimming variations while maintaining the same parameters.
user: Show practical ways to work with ObjectDisplay(bpy_struct) in a Blender add-on or script – include code.

assistant: # ObjectDisplay(bpy_struct)

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

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

    show_shadows
    :   Object cast shadows in the 3D viewport

        Type:
        :   boolean, default True

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type