PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is GeometryNodeMeshGrid(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeMeshGrid(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.GeometryNodeMeshGrid(*GeometryNode*)
:   Generate a planar mesh on the XY plane

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

assistant: # BlendDataPaintCurves(bpy_struct)

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

*class* bpy.types.BlendDataPaintCurves(*bpy_struct*)
:   Collection of paint curves

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: The usual way to add a driver to a property is to `RMB` click a property,
then choose *Add Driver* in the context menu.
Drivers can also be added by pressing `Ctrl`-`D` with the mouse over the property.

This operation adds a driver with a single variable (which needs to be filled in),
and displays the *Edit Driver* popover.
user: Show practical ways to work with Create Plane Track in a Blender add-on or script – include code.

assistant: The *Create Plane Track* operator creates a new plane track.
Planar tracking takes advantage of the fact that there are often planar surfaces in footage,
by attaching markers to points on these flat planes.
It can be used to replace things like billboards and screens on the footage with another image or video.
It also might be used for masking.

This button will create a plane object
which is deforming in the same way as plane defined by all selected point tracks.
At least four feature points tracked across the footage which belongs to
the plane you want to replace are needed. More tracks will give better estimation of plane motion.

Feature points used to estimate plane motion could be used from any place on the plane,
meaning it’s not necessarily need to be corners. Corners are not always easy to be tracked,
they might be occluded. In this case you can position tracked features that lay on the same plane
far away from the actual plane which should be replaced.

This provides more information about the possible deformation of the marker in following frames,
and such markers can be tracked even if partially occluded (appear and disappear during the time).
It is only required that two neighbor frames have at least four common tracks.

An image can be projected onto the plane with
the [Plane Track Deform Node](../../../../compositing/types/tracking/plane_track_deform.html) compositing node.
user: Give a detailed overview of skin.glue: syntax, arguments, return values, common patterns.

assistant: This rig is in concept similar to [skin.anchor](#skin-anchor), but instead of overriding controls,
it is used to read or adjust the state of controls generated by other rigs.
The head of the bone must overlap a control of another skin rig.

The rig sets up its ORG bone to read the state of the control,
while moving all constraints that were originally on the bone to the control.

Glue Mode
:   Specifies how the ORG bone is connected to the skin control.

    Child Of Control
    :   Makes the ORG bone a child of the control bone.

    Mirror Of Control
    :   Makes the ORG bone a sibling of the control with a Copy Transforms constraint from the control.
        The resulting local space transformation is the same as control’s local space.

    Mirror With Parents
    :   Parents the ORG bone to the parent automation a control owned by
        the glue rig would have had, while making it follow the actual control.
        This includes both direct and parent-induced motion of the control into
        the local space transformation of the bone.

    Deformation Bridge
    :   Other than adding glue constraints to the control, the rig acts as a one segment basic deform chain.
        This is convenient when a pair of controls need to be bridged both with glue and a deform bone.

Relink Constraints
:   Operates the same as in [basic.raw_copy](basic.xhtml#rigify-rigs-basic-raw-copy),
    except all constraints are moved from ORG to the control bone.

Use Tail Target
:   Relinks `TARGET` or any constraints with an empty target bone and no relink specification
    to reference the control located at the tail of the glue bone.

Target Local With Parents
:   Switches the tail target to operate similarly to *Mirror With Parents*.

Add Constraint
:   Allows to add a typical glue constraints with specific *Influence*, as if it were at
    the start of the ORG bone constraint stack.
user: What is Subdivision and how is it used in Blender Python scripting?

assistant: GPU Subdivision
:   Under certain circumstances, the GPU will be used to subdivide a mesh with a
    [Subdivision Surface modifier](../../modeling/modifiers/generate/subdivision_surface.xhtml).
    This typically results in increased subdivision performance.

    This feature is not supported on Qualcomm GPUs on Windows
user: Give a detailed overview of Hints: syntax, arguments, return values, common patterns.

assistant: Why would you use a lattice to deform a mesh instead of deforming the mesh itself in Edit Mode?
There are a couple of reasons for that:

- If your object has a large number of vertices, it would be difficult to edit portions of it quickly in Edit Mode.
  Using a lattice will allow you to deform large portions efficiently.
- The smooth deformation you get from a *Lattice* modifier can be hard to achieve manually.
- Multiple objects can use the same lattice, thus allowing you to edit multiple objects at once.
- Like all modifiers, it is non-destructive. Meaning all changes happen on top of the original geometry,
  which you can still go back to and edit without affecting the deformation.
- A lattice does not affect the texture coordinates of a mesh’s surface.
user: Describe Editor from the Blender manual or Python API, including usage steps and snippets.

assistant: The Keymap editor lets you change the default hotkeys for each of Blender’s editors.

[image reference removed]

Keymap editor.

Usage

1. Find the operation whose shortcut you want to change. Filtering can help with this.
2. Select whether the operation should be triggered by a keyboard key, a mouse button, or something else.
3. Click the button on the right and press the shortcut you want to assign.

Active
:   Uncheck the checkbox to disable this keymap item.

Map Type
:   Keyboard:
    :   Single hotkey or key combination.

    Mouse:
    :   Actions from mouse buttons, tablet or touchpad input.

    NDOF:
    :   Movement or button from a 3D mouse ([NDOF](../../glossary/index.xhtml#term-NDOF)) device.

    Tweak:
    :   Mouse click and drag *(optionally map drag direction to different actions)*.

    Text Input:
    :   Use this function by entering a text.

    Timer:
    :   For Blender internal use.

Operator ID Name
:   The identifier for the operator to call.

Event
:   Type
    :   The key or button that activates this keymap item (depending on the map type).

    Value
    :   The action (such as press, release, click, drag, etc.), (depending on the map type).

    Modifier
    :   Additional keys to hold (such as `Ctrl`, `Shift`, `Alt`).

Operator Properties
:   Initial values for the operator-specific properties.

### Restoring

If you want to restore the default settings for a keymap,
just click on the *Restore* button at the top right of this keymap.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Draw tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.xhtml#grease-pencil-draw-common-options) for more information.

### Free-hand Drawing

Click and hold `LMB` or use the pen tip to make free-hand drawing on the viewport.

Drawing free-hand strokes.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_draw_free-hand-01.png | ../../../../_images/grease-pencil_modes_draw_tools_draw_free-hand-02.png | ../../../../_images/grease-pencil_modes_draw_tools_draw_free-hand-03.png |

### Stabilize Stroke

`Shift`-`LMB` toggle the use of [Stabilize Stroke](../brushes/draw.xhtml#bpy-types-brushgpencilsettings-use-settings-stabilizer)
on the brush to have more control while drawing and get smoother lines.

Drawing strokes using *Stabilize Stroke*.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_draw_stabilizer-01.png | ../../../../_images/grease-pencil_modes_draw_tools_draw_stabilizer-02.png | ../../../../_images/grease-pencil_modes_draw_tools_draw_stabilizer-03.png |

### Straight Lines

`Alt`-`LMB` Constrains the drawing of the strokes to horizontal or vertical straight lines.

### Switching to the Erase Tool

`Ctrl`-`LMB` changes temporally to the active Erase tool.
See [Erase Tool](erase.xhtml) for more information.

You can also use `B` to delete all the points in the selected drawing area.
user: How do I use Split in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Split* operator separates the selected portion of a curve from the rest,
creating a new, independent curve segment.
This curve can then be moved or altered without affecting the other curve.

- If a segment of the curve is selected, it will be split off
  as a new curve that can be moved or edited independently.
- If only a single control point is selected, it will be duplicated as a loose control point,
  while the original remains attached to the rest of the curve.
user: Provide the full official documentation entry for Rig Types, preserving all code examples.

assistant: # Rig Types

Rig types are components used by Rigify to process specific parts of the meta-rig when generating the armature.
They represent common character features, like the spine, limbs, fingers etc.

This documents rig types that are bundled with Rigify.
user: Give a detailed overview of Updating Extensions: syntax, arguments, return values, common patterns.

assistant: You need to manually check for available updates.
Once an update is found, Blender will let you update any of the available extensions.

The current available version of an extension on the repository will always be considered the latest version.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`GreasePencilTreeNode.next_node`](#bpy.types.GreasePencilTreeNode.next_node "bpy.types.GreasePencilTreeNode.next_node") | - [`GreasePencilTreeNode.prev_node`](#bpy.types.GreasePencilTreeNode.prev_node "bpy.types.GreasePencilTreeNode.prev_node") |
user: Provide the full official documentation entry for Multiframe, preserving all code examples.

assistant: # Multiframe

[image reference removed]

Multiframe pop-over.

Multiframe allows you to draw, edit, sculpt, or weight painting on several frames at the same time.
Extremely useful to avoid repeating a task one frame at a time when animating.

Use Falloff
:   When enabled, the effects on the strokes start to falloff from the current frame
    as defined by a [curve widget](../interface/controls/templates/curve.xhtml).
user: How do I use VIEW3D_FH_empty_image(FileHandler) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VIEW3D_FH_empty_image(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.VIEW3D_FH_empty_image(*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: Provide the full official documentation entry for Weight Paint, preserving all code examples.

assistant: *Mesh skin weighting* is used to control how much a bone deforms the mesh of a character.
To visualize and paint these weights, Blender uses a color ramp (from blue to green, and from yellow to red).
Enabling the checkbox will enable an alternate map using a ramp starting with an empty range.
Now you can create your custom map using the common color ramp options.
For detailed information see the [Color ramps](../../interface/controls/templates/color_ramp.xhtml) page.
user: What is PathCompare(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PathCompare(bpy_struct)

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

*class* bpy.types.PathCompare(*bpy_struct*)
:   Match paths against this value

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

    use_glob
    :   Enable wildcard globbing

        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
user: What is MaskStrip(Strip) and how is it used in Blender Python scripting?

assistant: # MaskStrip(Strip)

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

*class* bpy.types.MaskStrip(*Strip*)
:   Sequence strip to load a video from a mask

    alpha_mode
    :   Representation of alpha information in the RGBA pixels

        - `STRAIGHT`
          Straight – RGB channels in transparent pixels are unaffected by the alpha channel.
        - `PREMUL`
          Premultiplied – RGB channels in transparent pixels are multiplied by the alpha channel.

        Type:
        :   enum in [`'STRAIGHT'`, `'PREMUL'`], default `'STRAIGHT'`

    animation_offset_end
    :   Animation end offset (trim end)

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

    animation_offset_start
    :   Animation start offset (trim start)

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

    color_multiply
    :   Type:
        :   float in [0, 20], default 1.0

    color_saturation
    :   Adjust the intensity of the input’s color

        Type:
        :   float in [0, 20], default 1.0

    crop
    :   Type:
        :   [`StripCrop`](bpy.types.StripCrop.html#bpy.types.StripCrop "bpy.types.StripCrop"), (readonly)

    mask
    :   Mask that this strip uses

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

    multiply_alpha
    :   Multiply alpha along with color channels

        Type:
        :   boolean, default False

    strobe
    :   Only display every nth frame

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

    transform
    :   Type:
        :   [`StripTransform`](bpy.types.StripTransform.html#bpy.types.StripTransform "bpy.types.StripTransform"), (readonly)

    use_deinterlace
    :   Remove fields from video movies

        Type:
        :   boolean, default False

    use_flip_x
    :   Flip on the X axis

        Type:
        :   boolean, default False

    use_flip_y
    :   Flip on the Y axis

        Type:
        :   boolean, default False

    use_float
    :   Convert input to float data

        Type:
        :   boolean, default False

    use_reverse_frames
    :   Reverse frame order

        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
user: What is Python Scripting and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| `Ctrl`-`C` | When pressed while hovering over an [operator button](../controls/buttons/buttons.xhtml#ui-operator-buttons), copies its Python command to the clipboard. This command can then be used in the [Python Console](../../editors/python_console.xhtml) or in the [Text Editor](../../editors/text_editor.xhtml) when writing scripts. |
| `Shift`-`Ctrl`-`C` | When pressed while hovering over a field, copies its relative data path (also available from the context menu). Useful when writing drivers or scripts. |
| `Shift`-`Ctrl`-`Alt`-`C` | When pressed while hovering over a field, copies its full data path. |
user: Describe Feature Sets from the Blender manual or Python API, including usage steps and snippets.

assistant: # Feature Sets

Rigify allows third party developers to implement sub-addons, called *Feature Sets*,
which can provide new [Meta-Rigs](metarigs.xhtml) and
[Rig Types](rig_types/index.xhtml). Similar to regular add-ons,
they can be installed from zip-files through Rigify settings.

These are some examples of *Feature Sets* currently provided by past and current Rigify developers:

[Cessen’s Rigify Extensions](https://github.com/cessen/cessen_rigify_ext)
:   This feature set provides the original Rigify rigs by Nathan Vegdahl, minimally ported
    and repackaged to work without switching Rigify to legacy mode. Note that their names
    were changed, so meta-rigs designed for legacy mode aren’t directly compatible.

[Experimental Rigs by Alexander Gavrilov](https://github.com/angavrilov/angavrilov-rigs)
:   Rig experiments, some of which might be included in Rigify in the future. Examples include
    limbs with an extra IK system based at knee/elbow, a spline based tentacle, and more.

You can install these packages by clicking Code ‣ Download ZIP,
and then install the downloaded file through Rigify settings.

Developer documentation is available on the [Blender Developer Documentation](https://developer.blender.org/docs/features/animation/rigify/).
user: Describe Views Format Multiview Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Views Format Multiview Items

INDIVIDUAL:
:   Individual.

    Individual files for each view with the prefix as defined by the scene views.

STEREO_3D:
:   Stereo 3D.

    Single file with an encoded stereo pair.

MULTIVIEW:
:   Multi-View.

    Single file with all the views.
user: Explain Wireframe Modifier in complete detail according to the official Blender documentation.

assistant: # Wireframe Modifier

The *Wireframe* modifier transforms a mesh into a wireframe by iterating over its
faces, collecting all edges and turning those edges into four-sided polygons.
Be aware of the fact that your mesh needs to have faces to be wireframed.
You can define the thickness, the material and several other parameters of the generated
wireframe dynamically via the given modifier options.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Type
:   The type of angle input.

    X/Y/Z Axis:
    :   Rotates the vector around the defined axis and
        the amount of rotation is defined by the *Angle* input.

    Axis Angle:
    :   Rotates the vector around an arbitrary axis defined by the *Axis* input vector.
        The amount of rotation is defined by the *Angle* input.

    Euler:
    :   Rotates the vector about a center point defined by the *Center* input vector.
        The amount of rotation on each axis is defined by the *Rotation* input vector.

Invert
:   Inverts the rotation angle.
user: How do I use GeometryNodeSDFGridMeanCurvature(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSDFGridMeanCurvature(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.GeometryNodeSDFGridMeanCurvature(*GeometryNode*)
:   Apply mean curvature flow smoothing to a signed distance field. Evolves the surface based on its mean curvature, naturally smoothing high-curvature regions more than flat areas

    *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: How do I use GeometryNodeToolActiveElement(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeToolActiveElement(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.GeometryNodeToolActiveElement(*GeometryNode*)
:   Active element indices of the edited geometry, for tool execution

    domain
    :   Type:
        :   enum in [`'POINT'`, `'EDGE'`, `'FACE'`, `'LAYER'`], default `'POINT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Fill Curve Node

[image reference removed]

The *Fill Curve* node generates a mesh using the constrained Delaunay triangulation algorithm
with the curves as boundaries. The mesh is only generated flat with a local Z of 0.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketMaterial(NodeTreeInterfaceSocket), preserving all code examples.

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

    default_value
    :   Input value used for unconnected socket

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

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Constraint.name`](bpy.types.Constraint.html#bpy.types.Constraint.name "bpy.types.Constraint.name") - [`Constraint.type`](bpy.types.Constraint.html#bpy.types.Constraint.type "bpy.types.Constraint.type") - [`Constraint.is_override_data`](bpy.types.Constraint.html#bpy.types.Constraint.is_override_data "bpy.types.Constraint.is_override_data") - [`Constraint.owner_space`](bpy.types.Constraint.html#bpy.types.Constraint.owner_space "bpy.types.Constraint.owner_space") - [`Constraint.target_space`](bpy.types.Constraint.html#bpy.types.Constraint.target_space "bpy.types.Constraint.target_space") - [`Constraint.space_object`](bpy.types.Constraint.html#bpy.types.Constraint.space_object "bpy.types.Constraint.space_object") - [`Constraint.space_subtarget`](bpy.types.Constraint.html#bpy.types.Constraint.space_subtarget "bpy.types.Constraint.space_subtarget") | - [`Constraint.mute`](bpy.types.Constraint.html#bpy.types.Constraint.mute "bpy.types.Constraint.mute") - [`Constraint.enabled`](bpy.types.Constraint.html#bpy.types.Constraint.enabled "bpy.types.Constraint.enabled") - [`Constraint.show_expanded`](bpy.types.Constraint.html#bpy.types.Constraint.show_expanded "bpy.types.Constraint.show_expanded") - [`Constraint.is_valid`](bpy.types.Constraint.html#bpy.types.Constraint.is_valid "bpy.types.Constraint.is_valid") - [`Constraint.active`](bpy.types.Constraint.html#bpy.types.Constraint.active "bpy.types.Constraint.active") - [`Constraint.influence`](bpy.types.Constraint.html#bpy.types.Constraint.influence "bpy.types.Constraint.influence") - [`Constraint.error_location`](bpy.types.Constraint.html#bpy.types.Constraint.error_location "bpy.types.Constraint.error_location") - [`Constraint.error_rotation`](bpy.types.Constraint.html#bpy.types.Constraint.error_rotation "bpy.types.Constraint.error_rotation") |
user: Describe Triangulate Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Triangulate Node

[image reference removed]

The *Triangulate* node converts all faces in a mesh (quads and n-gons) to triangular faces.
It functions the same as the [Triangulate](../../../meshes/editing/face/triangulate_faces.xhtml#bpy-ops-mesh-quads-convert-to-tris) tool in Edit Mode.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Clamp Type
:   Method to clamp.

    Min Max:
    :   Constrain values between Min and Max.

    Range:
    :   Constrain values between Min and Max. When Min is greater than Max,
        constrain between Max and Min instead.
user: Provide the full official documentation entry for Brush Automasking Flag Items, preserving all code examples.

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Modifier.name`](bpy.types.Modifier.html#bpy.types.Modifier.name "bpy.types.Modifier.name") - [`Modifier.type`](bpy.types.Modifier.html#bpy.types.Modifier.type "bpy.types.Modifier.type") - [`Modifier.show_viewport`](bpy.types.Modifier.html#bpy.types.Modifier.show_viewport "bpy.types.Modifier.show_viewport") - [`Modifier.show_render`](bpy.types.Modifier.html#bpy.types.Modifier.show_render "bpy.types.Modifier.show_render") - [`Modifier.show_in_editmode`](bpy.types.Modifier.html#bpy.types.Modifier.show_in_editmode "bpy.types.Modifier.show_in_editmode") - [`Modifier.show_on_cage`](bpy.types.Modifier.html#bpy.types.Modifier.show_on_cage "bpy.types.Modifier.show_on_cage") | - [`Modifier.show_expanded`](bpy.types.Modifier.html#bpy.types.Modifier.show_expanded "bpy.types.Modifier.show_expanded") - [`Modifier.is_active`](bpy.types.Modifier.html#bpy.types.Modifier.is_active "bpy.types.Modifier.is_active") - [`Modifier.use_pin_to_last`](bpy.types.Modifier.html#bpy.types.Modifier.use_pin_to_last "bpy.types.Modifier.use_pin_to_last") - [`Modifier.is_override_data`](bpy.types.Modifier.html#bpy.types.Modifier.is_override_data "bpy.types.Modifier.is_override_data") - [`Modifier.use_apply_on_spline`](bpy.types.Modifier.html#bpy.types.Modifier.use_apply_on_spline "bpy.types.Modifier.use_apply_on_spline") - [`Modifier.execution_time`](bpy.types.Modifier.html#bpy.types.Modifier.execution_time "bpy.types.Modifier.execution_time") - [`Modifier.persistent_uid`](bpy.types.Modifier.html#bpy.types.Modifier.persistent_uid "bpy.types.Modifier.persistent_uid") |
user: Provide the full official documentation entry for String to Value Node, preserving all code examples.

assistant: # String to Value Node

[image reference removed]

The *String to Value* node converts a text string into a numerical value.
This is useful for parsing numbers from text input, file data, or dynamically generated strings.

The node reads characters from the beginning of the string until a valid number is parsed.
If parsing is unsuccessful, the node outputs a floating-point value of 0.
user: Give a detailed overview of Combine Cylindrical Node: syntax, arguments, return values, common patterns.

assistant: # Combine Cylindrical Node

[image reference removed]

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

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: Show practical ways to work with LineStyleColorModifier(LineStyleModifier) in a Blender add-on or script – include code.

assistant: # LineStyleColorModifier(LineStyleModifier)

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")

subclasses —
[`LineStyleColorModifier_AlongStroke`](bpy.types.LineStyleColorModifier_AlongStroke.html#bpy.types.LineStyleColorModifier_AlongStroke "bpy.types.LineStyleColorModifier_AlongStroke"), [`LineStyleColorModifier_CreaseAngle`](bpy.types.LineStyleColorModifier_CreaseAngle.html#bpy.types.LineStyleColorModifier_CreaseAngle "bpy.types.LineStyleColorModifier_CreaseAngle"), [`LineStyleColorModifier_Curvature_3D`](bpy.types.LineStyleColorModifier_Curvature_3D.html#bpy.types.LineStyleColorModifier_Curvature_3D "bpy.types.LineStyleColorModifier_Curvature_3D"), [`LineStyleColorModifier_DistanceFromCamera`](bpy.types.LineStyleColorModifier_DistanceFromCamera.html#bpy.types.LineStyleColorModifier_DistanceFromCamera "bpy.types.LineStyleColorModifier_DistanceFromCamera"), [`LineStyleColorModifier_DistanceFromObject`](bpy.types.LineStyleColorModifier_DistanceFromObject.html#bpy.types.LineStyleColorModifier_DistanceFromObject "bpy.types.LineStyleColorModifier_DistanceFromObject"), [`LineStyleColorModifier_Material`](bpy.types.LineStyleColorModifier_Material.html#bpy.types.LineStyleColorModifier_Material "bpy.types.LineStyleColorModifier_Material"), [`LineStyleColorModifier_Noise`](bpy.types.LineStyleColorModifier_Noise.html#bpy.types.LineStyleColorModifier_Noise "bpy.types.LineStyleColorModifier_Noise"), [`LineStyleColorModifier_Tangent`](bpy.types.LineStyleColorModifier_Tangent.html#bpy.types.LineStyleColorModifier_Tangent "bpy.types.LineStyleColorModifier_Tangent")

*class* bpy.types.LineStyleColorModifier(*LineStyleModifier*)
:   Base type to define line color modifiers

    name
    :   Name of the modifier

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Face sets are used to group your mesh into differently colored faces,
which can then be quickly hidden or shown like mentioned above.
They can also be used for fast mask creation via the [Mask Expand](../editing/expand.html#bpy-ops-sculpt-expand).
[Face Set Expand](../editing/expand.html#face-set-expand) is also useful for creating, editing and joining face sets.

More options can be found in the `Alt`-`W` pie menu.

[image reference removed]

Otherwise Face Sets can be created/edited with the
[Draw Face Sets](../brushes/draw_facesets.html) brush,
[Mask Gesture Tools](../tools/mask_tools.html).
They can also be edited with the
[Edit Face Set](../tools/edit_face_set.html) tool.

Internally, face sets are stored using the `sculpt_face_set` [Attributes](../../../modeling/geometry_nodes/attributes_reference.html).
user: Provide the full official documentation entry for Attributes, preserving all code examples.

assistant: Geometry attributes can be read through the `getattribute()` function.
This includes UV maps, color attributes and any attributes output from geometry nodes.

The following built-in attributes are available through `getattribute()` as well.

`geom:generated`
:   Automatically generated texture coordinates, from non-deformed mesh.

`geom:uv`
:   Default render UV map.

`geom:tangent`
:   Default tangent vector along surface, in object space.

`geom:undisplaced`
:   Position before displacement, in object space.

`geom:dupli_generated`
:   For instances, generated coordinate from instancer object.

`geom:dupli_uv`
:   For instances, UV coordinate from instancer object.

`geom:trianglevertices`
:   Three vertex coordinates of the triangle.

`geom:numpolyvertices`
:   Number of vertices in the polygon (always returns three currently).

`geom:polyvertices`
:   Vertex coordinates array of the polygon (always three vertices currently).

`geom:name`
:   Name of the object.

`geom:is_smooth`
:   Is mesh face smooth or flat shaded.

`geom:is_curve`
:   Is object a curve or not.

`geom:curve_intercept`
:   0..1 coordinate for point along the curve, from root to tip.

`geom:curve_thickness`
:   Thickness of the curve in object space.

`geom:curve_length`
:   Length of the curve in object space.

`geom:curve_tangent_normal`
:   Tangent Normal of the strand.

`geom:is_point`
:   Is point in a point cloud or not.

`geom:point_radius`
:   Radius of point in point cloud.

`geom:point_position`
:   Center position of point in point cloud.

`geom:point_random`
:   Random number, different for every point in point cloud.

`path:ray_length`
:   Ray distance since last hit.

`object:random`
:   Random number, different for every object instance.

`object:index`
:   Object unique instance index.

`object:location`
:   Object location.

`material:index`
:   Material unique index number.

`particle:index`
:   Particle unique instance number.

`particle:age`
:   Particle age in frames.

`particle:lifetime`
:   Total lifespan of particle in frames.

`particle:location`
:   Location of the particle.

`particle:size`
:   Size of the particle.

`particle:velocity`
:   Velocity of the particle.

`particle:angular_velocity`
:   Angular velocity of the particle.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.texture_user_property`](bpy.context.html#bpy.context.texture_user_property "bpy.context.texture_user_property") - [`Function.parameters`](bpy.types.Function.html#bpy.types.Function.parameters "bpy.types.Function.parameters") | - [`Struct.properties`](bpy.types.Struct.html#bpy.types.Struct.properties "bpy.types.Struct.properties") |
user: Provide the full official documentation entry for GeometryNodeListGetItem(GeometryNode), preserving all code examples.

assistant: # GeometryNodeListGetItem(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.GeometryNodeListGetItem(*GeometryNode*)
:   Retrieve a value from a list

    data_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'GEOMETRY'`

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

assistant: # Introduction

Draw Mode is the mode in Grease Pencil that allows you to draw in the 3D Viewport.
This mode is actually the only one in which new strokes can be created.

Already made strokes can not be selected in Draw Mode, for editing strokes you must use
the [Edit Mode](../edit/introduction.html) or
[Sculpt Mode](../sculpting/introduction.html).

[image reference removed]

3D Viewport Mode selector: Draw Mode.

Draw Mode is selected with the *Mode* menu in the 3D Viewport header.
Once Draw Mode is activated, the Toolbar of the 3D Viewport will change to Draw Mode specific panels.
Also a circle with the same color as the active material will appear and
follow the location of the cursor in the 3D Viewport.

To create new strokes you have to select one of the drawing tools in the Toolbar.
The most common one is the [Draw tool](tools.html)
for free-hand drawings but there are many other tools for drawing, filling areas and erasing strokes.
There are also some tools to create primitives shapes like lines, arcs, curves, boxes and circles.

See [Toolbar](tools.html) for more details.
user: Give a detailed overview of NlaStripFCurves(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NlaStripFCurves(bpy_struct)

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

*class* bpy.types.NlaStripFCurves(*bpy_struct*)
:   Collection of NLA strip F-Curves

    find(*data_path*, *\**, *index=0*)
    :   Find an F-Curve. Note that this function performs a linear scan of all F-Curves in the NLA strip.

        Parameters:
        :   - **data_path** (*string**,* *(**never None**)*) – Data Path, F-Curve data path
            - **index** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Index, Array index

        Returns:
        :   The found F-Curve, or None if it doesn’t exist

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

    *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