PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Brush Gpencil Vertex Types Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Brush Gpencil Vertex Types Items

DRAW:
:   Draw.

    Paint a color on stroke points.

BLUR:
:   Blur.

    Smooth out the colors of adjacent stroke points.

AVERAGE:
:   Average.

    Smooth out colors with the average color under the brush.

SMEAR:
:   Smear.

    Smudge colors by grabbing and dragging them.

REPLACE:
:   Replace.

    Replace the color of stroke points that already have a color applied.
user: How do I use Workspace Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Workspace Operators

bpy.ops.workspace.add()
:   Add a new workspace by duplicating the current one or appending one from the user configuration

bpy.ops.workspace.append_activate(*\**, *idname=''*, *filepath=''*)
:   Append a workspace and make it the active one in the current window

    Parameters:
    :   - **idname** (*string**,* *(**optional**,* *never None**)*) – Identifier, Name of the workspace to append and activate
        - **filepath** (string, (optional, never None, blend relative `//` prefix supported)) – Filepath, Path to the library

bpy.ops.workspace.delete()
:   Delete the active workspace

bpy.ops.workspace.delete_all_others()
:   Delete all workspaces except this one

bpy.ops.workspace.duplicate()
:   Add a new workspace

bpy.ops.workspace.reorder_to_back()
:   Reorder workspace to be last in the list

bpy.ops.workspace.reorder_to_front()
:   Reorder workspace to be first in the list

bpy.ops.workspace.scene_pin_toggle()
:   Remember the last used scene for the current workspace and switch to it whenever this workspace is activated again
user: Explain Before Reporting in complete detail according to the official Blender documentation.

assistant: Before reporting a bug, some basic steps should be taken to ensure that you are reporting a real issue.

- Ensure you have installed Blender according to the guidance in this manual under
  [Installing Blender](../getting_started/installing/index.xhtml).
- Follow the steps in this Troubleshooting section first, starting with loading factory settings. Many crashes and
  errors may be caused by bad settings or add-ons that have not been updated to work with the newest release of
  Blender.
user: What is Render Properties and how is it used in Blender Python scripting?

assistant: # Render Properties

Freestyle can be activated with the checkbox in the header of the Freestyle panel in the *Render* tab.

[image reference removed]

Freestyle Render Properties.

Line Thickness Mode
:   There are two different modes for defining the base line thickness:

    Absolute:
    :   The line thickness is given by a user-specified number of pixels.

    Relative:
    :   The unit line thickness is scaled by the proportion of the present vertical image resolution to 480 pixels.
        For instance, the “unit line thickness” is 1.0 when the image height set to 480px, 1.5 with 720px
        and 2.0 with 960px.

Line Thickness
:   Line thickness to use for rendering (only for *Absolute* line thickness).
user: Describe LineStyleGeometryModifier_2DTransform(LineStyleGeometryModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleGeometryModifier_2DTransform(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_2DTransform(*LineStyleGeometryModifier*)
:   Apply two-dimensional scaling and rotation to stroke backbone geometry

    angle
    :   Rotation angle

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    pivot
    :   Pivot of scaling and rotation operations

        Type:
        :   enum in [`'CENTER'`, `'START'`, `'END'`, `'PARAM'`, `'ABSOLUTE'`], default `'CENTER'`

    pivot_u
    :   Pivot in terms of the stroke point parameter u (0 <= u <= 1)

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

    pivot_x
    :   2D X coordinate of the absolute pivot

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

    pivot_y
    :   2D Y coordinate of the absolute pivot

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

    scale_x
    :   Scaling factor that is applied along the X axis

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

    scale_y
    :   Scaling factor that is applied along the Y axis

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

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_2DTransform.type "bpy.types.LineStyleGeometryModifier_2DTransform.type")
user: Show practical ways to work with Rendering in a Blender add-on or script – include code.

assistant: Activating *Viewport Render* will render from the current active view.
This means that if you are not in an active camera view,
a virtual camera is used to match the current perspective.
To get an image from the camera point of view,
enter the active camera view with `Numpad0`.

As with a normal render, you can abort it with `Esc`.

Render a Still Image
:   To render a still image, use 3D Viewport ‣ View ‣ Render Viewport Preview.

Render an Animation
:   To render an animation, use 3D Viewport ‣ View ‣ Render Playblast.

Render Keyframes
:   To render an animation, but only those frames that have a keyframe, use 3D Viewport ‣ View ‣ Render Playblast on Keyframes. This only renders those frames for which the selected objects have an animation key. The other frames are still written to the output, but will simply repeat the last-rendered frame.

    For example, when a six-frame animation is rendered, and the selected objects have a key on frames 3 and 5, the following frames will be output:

    1. The 1st frame is always rendered.
    2. The 1st frame is repeated because there is no key on this frame.
    3. The 3rd frame is rendered.
    4. The 3rd frame is repeated because there is no key on this frame.
    5. The 5th frame is rendered.
    6. The 5th frame is repeated because there is no key on this frame.
user: What is Evaluate at Index Node and how is it used in Blender Python scripting?

assistant: # Evaluate at Index Node

[image reference removed]

The *Evaluate at Index* node allows accessing data of other elements in the context geometry.
It is similar to the [Sample Index Node](../../geometry/sample/sample_index.xhtml).
The main difference is that this node does not require a geometry input, because the geometry
from the [field context](../../fields.xhtml#field-context) is used.

This node is also similar to the [Evaluate on Domain Node](evaluate_on_domain.xhtml) node,
except that the value to retrieve from the specified domain is specified by an index rather than
an automatic domain interpolation.
user: Explain Material Settings in complete detail according to the official Blender documentation.

assistant: Pass Index
:   Index number for the *Material Index* [render pass](../layers/passes.xhtml).
    This can be used to give a mask to a material which then can be read with
    the [ID Mask Node](../../compositing/types/mask/id_mask.xhtml) in the Compositor.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Guide Curves
:   Base curves that new curves are interpolated between.

Guide Up
:   Optional up vector that is typically a surface normal. Supplying an up vector will improve
    the quality of the interpolation, making it aware of the surface shape which it otherwise
    wouldn’t have a way to know about.

Guide Group ID
:   Splits guides into separate groups. New curves interpolate existing curves from a single group.
    This input can be useful for generating hair parts by stopping curves in different sections
    (with different group IDs) from affecting each other.

Points
:   The positions of the first root control points of the newly generated interpolated curves.

Points Up
:   Optional up vector that is typically a surface normal.

Point Group ID
:   The curve group to interpolate in.

Max Neighbors
:   Maximum amount of close guide curves that are taken into account for interpolation.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Corner Index
:   The geometry-wide index of the selected corner. You can pass this to the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml) or the
    [Sample Index Node](../../geometry/sample/sample_index.xhtml) (with the domain set to Face Corner)
    to retrieve details about the corner.

Total
:   The number of corners in the face, which is also its number of edges.
user: Give a detailed overview of Script Directories: syntax, arguments, return values, common patterns.

assistant: Additional locations to search for Python scripts.

Each path can be given a *Name* to signify to purpose of that script directory.

By default, Blender looks in several directories (platform dependent) for scripts.
By adding a user script path in the preferences an additional directory is used.
This can be used to store your own scripts and add-ons independently of the current Blender version.

You will need to create specific subfolders in this path which match the structure of the `scripts`
folder found in Blender’s installation directory.

The following subdirectories will be used when present:

`startup/`
:   Modules in this folder will be imported on startup.

`addons/`
:   Legacy add-ons located here will be listed in the add-ons preferences.

`modules/`
:   Modules in this folder can be imported by other scripts.

`presets/`
:   Presets in this folder will be added to existing presets.
user: Explain GeometryNodeSetCurveHandlePositions(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSetCurveHandlePositions(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.GeometryNodeSetCurveHandlePositions(*GeometryNode*)
:   Set the positions for the handles of Bézier curves

    mode
    :   Whether to update left and right handles

        Type:
        :   enum in [Node Geometry Curve Handle Side Items](bpy_types_enum_items/node_geometry_curve_handle_side_items.html#rna-enum-node-geometry-curve-handle-side-items), default `'LEFT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Guides

Fluid guides are used to apply forces onto the simulation. They are like simple external forces
but also seek to preserve the physically accurate flow of the fluid.
The *Guides* panel allows you to adjust guiding forces globally, i.e. for the entire domain.
Enabling the guides hints the fluid solver to use the more accurate,
but also computationally more expensive pressure solving step.

Even when there are no guiding objects baked or there is no guiding domain attached,
the fluid solver will still perform the more expensive pressure guiding algorithm
if guiding is enabled. It is
therefore recommended to only enable *Guides* when there is a clear intention to
use guiding in the simulation.

Weight
:   Controls the lag of the guiding. A larger value (also known as the ‘alpha’ guiding value)
    results in a greater lag.

Size
:   This setting determines the size of the vortices that the guiding produces.
    A greater guiding size (also known as the blur radius or ‘beta’ guiding value)
    results in larger vortices.

Velocity Factor
:   All guiding velocities are multiplied by this factor. That is, every cell of the guiding grid,
    which has the same size as the domain object, is multiplied by this factor.

Velocity Source
:   Guiding velocities can either come from objects that move inside the domain or from other fluid
    domains.

    Effector:
    :   All effector objects inside the domain will be considered for the global guiding velocity grid.
        Once effector objects have been baked it is not possible to change the fluid domain resolution
        anymore.

    Domain:
    :   When using another fluid domain as the guiding velocity source this domain may have a different
        resolution and may also be of a different type (e.g. the guiding domain is of type *Gas*
        while the actual domain with the guiding effect in it is of type *Liquid*).

        In order to use a domain as the velocity source, this domain needs to be baked already.

Guide Parent
:   When using *Domain* as the velocity source, this field serves to select the guiding domain object.

Bake Guides, Free Guides
:   This option is only available when using the [Modular](cache.html#bpy-types-fluiddomainsettings-cache-type) cache type
    and when using *Effector* as the [Velocity Source](#bpy-types-fluiddomainsettings-guide-source).
    *Bake Guides* writes vertex velocities of effector objects to drive.
    It is meant to be used before baking the fluid simulation.

    The progress will be displayed in the status bar. Pressing `Esc` will pause the simulation.

    Once the simulation has been baked, the cache can be deleted by pressing *Free Guides*.
    It is possible to pause or resume a *Bake Guides* process.
user: Show practical ways to work with Guides in a Blender add-on or script – include code.

assistant: # Guides

Fluid guides are used to apply forces onto the simulation. They are like simple external forces
but also seek to preserve the physically accurate flow of the fluid.
The *Guides* panel allows you to adjust guiding forces globally, i.e. for the entire domain.
Enabling the guides hints the fluid solver to use the more accurate,
but also computationally more expensive pressure solving step.

Even when there are no guiding objects baked or there is no guiding domain attached,
the fluid solver will still perform the more expensive pressure guiding algorithm
if guiding is enabled. It is
therefore recommended to only enable *Guides* when there is a clear intention to
use guiding in the simulation.

Weight
:   Controls the lag of the guiding. A larger value (also known as the ‘alpha’ guiding value)
    results in a greater lag.

Size
:   This setting determines the size of the vortices that the guiding produces.
    A greater guiding size (also known as the blur radius or ‘beta’ guiding value)
    results in larger vortices.

Velocity Factor
:   All guiding velocities are multiplied by this factor. That is, every cell of the guiding grid,
    which has the same size as the domain object, is multiplied by this factor.

Velocity Source
:   Guiding velocities can either come from objects that move inside the domain or from other fluid
    domains.

    Effector:
    :   All effector objects inside the domain will be considered for the global guiding velocity grid.
        Once effector objects have been baked it is not possible to change the fluid domain resolution
        anymore.

    Domain:
    :   When using another fluid domain as the guiding velocity source this domain may have a different
        resolution and may also be of a different type (e.g. the guiding domain is of type *Gas*
        while the actual domain with the guiding effect in it is of type *Liquid*).

        In order to use a domain as the velocity source, this domain needs to be baked already.

Guide Parent
:   When using *Domain* as the velocity source, this field serves to select the guiding domain object.

Bake Guides, Free Guides
:   This option is only available when using the [Modular](cache.xhtml#bpy-types-fluiddomainsettings-cache-type) cache type
    and when using *Effector* as the [Velocity Source](#bpy-types-fluiddomainsettings-guide-source).
    *Bake Guides* writes vertex velocities of effector objects to drive.
    It is meant to be used before baking the fluid simulation.

    The progress will be displayed in the status bar. Pressing `Esc` will pause the simulation.

    Once the simulation has been baked, the cache can be deleted by pressing *Free Guides*.
    It is possible to pause or resume a *Bake Guides* process.
user: Describe Saving Images from the Blender manual or Python API, including usage steps and snippets.

assistant: File Format
:   Choose the image file format to save to. Based on which format is used,
    other options such as channels, bit depth and compression level are available.

Color
:   The color format to save the image or video to.
    This setting is used by some formats to optimize how much data is written to the file.
    Note, *RGBA* is not available for all image formats, check the list above for details.

    BW:
    :   Saves the image using grayscale colors.

    RGB:
    :   Saves red, green and blue channels

    RGBA:
    :   Saves red, green, blue and alpha channels.

Color Depth
:   Defines the bit depth per color channel, determining how many color values can be represented.

    Higher bit depths reduce color banding and improve precision but also increase file size and memory usage.
    Note, not all file formats support all color depths.

    8:
    :   Most common for on-screen graphics, web, and standard video. Suitable for general-purpose use.

    10, 12, 16:
    :   Used by formats focused on photography and digital cinema (e.g., DPX, JPEG 2000).
        Provides more tonal range and color detail than 8-bit.

    32:
    :   32-bit floating point per channel. Provides the highest precision and dynamic range.
        Highest possible color depth, primarily used with OpenEXR for visual effects and compositing workflows.

    Float (Half):
    :   16-bit floating point per channel. Offers high dynamic range with lower memory and storage usage.
        Only supported for OpenEXR files.

    Float (Full):
    :   32-bit floating point per channel. Provides the highest precision and dynamic range.
        Only supported for OpenEXR files.

Compression
:   Used to reduce the size of the image file.
    How this is done may vary depending on the file format and settings used.

Quality
:   Controls the level of lossy compression applied to the image, expressed as a percentage.
    Lossy compression reduces file size by discarding some image data, which may result in a loss of detail.

    - **0%**: Maximum compression, producing the smallest file size but the most noticeable quality loss.
    - **100%**: No compression, preserving full image quality at the cost of a larger file size.

Save As Render
:   Save image with render [color management](../../render/color_management/index.xhtml).
    For display image formats like PNG, apply view and display transform.
    For intermediate image formats like OpenEXR, use the default render output color space.

Copy
:   Defines if the data-block will reference the newly created file
    or the reference will be unchanged, maintaining it with the original one.

Color Space
:   To specify the color space of the source file.

    The list of color spaces depends on the active [OCIO config](../../render/color_management/opencolorio.xhtml#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../render/color_management/color_spaces.xhtml#ocio-config-default-color-spaces)
user: How do I use Glass BSDF in Blender? Include parameters, examples, warnings and best practices.

assistant: # Glass BSDF

[image reference removed]

The *Glass* BSDF
is used to add a Glass-like shader mixing refraction and reflection at grazing angles.
Like the transparent shader, only pure white will make it transparent.
The glass shader tends to cause noise due to caustics.
Since the Cycles path tracing integrator is not very good at rendering caustics,
it helps to combine this with a transparent shader for shadows;
for [more details see here](../../cycles/optimizations/reducing_noise.html#render-cycles-reducing-noise-glass-and-transp-shadows).
user: What is Normalization and how is it used in Blender Python scripting?

assistant: Often, kernels are normalized so that the sum of all values equals 1.
This prevents overall brightening or darkening of the image.
For example, dividing each element of a blur kernel by the total sum of all values ensures
consistent brightness after convolution.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Color1, Color 2
:   Color of the checkers.

Scale
:   Overall texture scale. The scale is a factor of the bounding box of the face divided by the scale.
    For example, a scale of 15 will result in 15 alternate patterns over the overall UV bounding box.
    Different patterns could be achieved using other nodes to give different input patterns to this socket.
    For example, using the Math node.
user: What is Examples and how is it used in Blender Python scripting?

assistant: Combined with the [Index of Nearest](../geometry/sample/index_of_nearest.xhtml),
this can be used for a number of sphere-based simulations.

[image reference removed]

Index of Nearest sample file CC-BY Sean Christofferson.
user: How do I use Wave Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Wave Modifier

The *Wave* modifier adds a ripple-like motion to an object’s geometry.

This modifier is available for meshes, lattices, curves, surfaces and texts.

|  |  |  |
| --- | --- | --- |
| <../../../_images/modeling_modifiers_deform_wave_example-circular.jpg>   Circular wave front. | <../../../_images/modeling_modifiers_deform_wave_example-linear.jpg>   Linear wave front. | <../../../_images/modeling_modifiers_deform_wave_example-normals.jpg>   Motion enabled for X, Normals enabled for Y. |
user: What is Selection Sets and how is it used in Blender Python scripting?

assistant: # Selection Sets

Selection Sets are a feature that allows the definition of sets of bones for easy selection while animating.
The sets can be created in local and linked armature overrides.

Selection Set
:   A [List View](../../../interface/controls/templates/list_view.xhtml#ui-list-view) listing all selection sets for the selected armature.
    Here, selection sets can be renamed by double clicking on the name.

    To the right of the name is a check box to include that selection set when copying to the clipboard.

Specials

Delete All Sets
:   Removes all selection sets from the list.

Remove Selected Bones from All Sets
:   Removes the selected bones from all selection sets.

Copy Selected Set(s)
:   Copies the selected set to Blender’s clipboard.

Paste Selected Set(s)
:   Pastes a selection set from Blender’s clipboard.

---

Assign
:   Assigns the selected bones to the active selection set.

Remove
:   Removes the selected bones to the active selection set.

Select
:   Selects all the bones in the active selection set.

Deselect
:   Deselects all the bones in the active selection set.
user: Provide the full official documentation entry for Upload, preserving all code examples.

assistant: When you are happy with your changes, you can upload them, so that they will be in the online manual. At first, this
is done by submitting patches so that someone can review your changes and give you feedback. After, you can commit
your changes directly. This process is described in detail in the next section.
user: Provide the full official documentation entry for Contribute Documentation, preserving all code examples.

assistant: # Contribute Documentation

The Blender Manual is a community driven effort to which anyone can contribute. Whether you’d like to fix a tiny
spelling mistake or rewrite an entire chapter, your help with the Blender manual is most welcome!

If you find an error in the documentation, please [report the problem](https://projects.blender.org/blender/documentation/issues/new).

Get involved in discussions through any of the project [Contacts](#contacts).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Transform Cache Constraint.

Cache File
:   Data-block menu to select the Alembic or USD file.

File Path
:   Path to the Alembic or USD file.

Sequence
:   Whether or not the cache is separated in a series of files.

Override Frame
:   Whether to use a custom frame for looking up data in the cache file,
    instead of using the current scene frame.

    The *Frame* value is the time to use for looking up the data in the cache file,
    or to determine which to use in a file sequence.

Frame Offset
:   Subtracted from the current frame to use for looking up the data in the cache file,
    or to determine which file to use in a file sequence.

Manual Scale
:   Value by which to enlarge or shrink the object with respect to the world’s origin.

Velocity Attribute
:   The name of the Alembic attribute used for generating motion blur data;
    by default, this is `.velocities` which is standard for most Alembic files.

Velocity Unit
:   Defines how the velocity vectors are interpreted with regard to time.

    Frame:
    :   The velocity unit was encoded in frames and does not need to be scaled by scene FPS.

    Second:
    :   The velocity unit was encoded in seconds and needs to be scaled by the scene FPS (1 / FPS).

Object Path
:   The path to the Alembic or USD object inside the archive or stage.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the object.
user: Explain Brush Settings in complete detail according to the official Blender documentation.

assistant: ### General

Size
:   Pressure Sensitivity is not supported for this brush type. More info at [Size](../../brush/brush_settings.xhtml#bpy-types-brush-size).

Strength
:   Pressure Sensitivity is not supported for this brush type. More info at [Strength](../../brush/brush_settings.xhtml#bpy-types-brush-strength).

Normal Radius
:   For this brush, this setting is a purely visual change.
    It does not alter the brush behavior. More info at [Normal Radius](../../brush/brush_settings.xhtml#bpy-types-brush-normal-radius-factor).

Auto-Smooth
:   This setting is not supported. More info at [Auto-Smooth](../../brush/brush_settings.xhtml#bpy-types-brush-auto-smooth-factor).

### Unique

Grab Active Vertex
:   Applies the maximum strength of the brush to the highlighted active vertex,
    making it easier to manipulate low-poly models or meshes with modifiers.

    Enabling this option also enables a white wireframe overlay within the brush radius.
    This helps to visualize the real base geometry that is being manipulated
    while sculpting with [Modifiers](../../../modeling/modifiers/index.xhtml).

[image reference removed]

Grab Silhouette
:   Preserves the object’s silhouette shape by only grabbing vertices on one side of the mesh curvature.
    The shape of the silhouette is determined by the orientation of the 3D Viewport and the start of the stroke.

[image reference removed]

Note how in the image only the bottom side of the leg is pulled down, despite the size of the brush.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

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.html#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.html#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.html) for more information.

You can also use `B` to delete all the points in the selected drawing area.
user: Describe KeyingSetPath(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # KeyingSetPath(bpy_struct)

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

*class* bpy.types.KeyingSetPath(*bpy_struct*)
:   Path to a setting for use in a Keying Set

    array_index
    :   Index to the specific setting if applicable

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

    data_path
    :   Path to property setting

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

    group
    :   Name of Action Group to assign setting(s) for this path to

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

    group_method
    :   Method used to define which Group-name to use

        Type:
        :   enum in [Keyingset Path Grouping Items](bpy_types_enum_items/keyingset_path_grouping_items.html#rna-enum-keyingset-path-grouping-items), default `'NAMED'`

    id
    :   ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)

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

    id_type
    :   Type of ID-block that can be used

        Type:
        :   enum in [Id Type Items](bpy_types_enum_items/id_type_items.html#rna-enum-id-type-items), default `'OBJECT'`

    use_entire_array
    :   When an ‘array/vector’ type is chosen (Location, Rotation, Color, etc.), entire array is to be used

        Type:
        :   boolean, default False

    use_insertkey_needed
    :   Only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_needed
    :   Override default setting to only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_visual
    :   Override default setting to insert keyframes based on ‘visual transforms’

        Type:
        :   boolean, default False

    use_insertkey_visual
    :   Insert keyframes based on ‘visual transforms’

        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: Give a detailed overview of Splines: syntax, arguments, return values, common patterns.

assistant: Splines are the fundamental components of curve objects, defining their shapes.
A curve object can consist of multiple splines,
similar to how a mesh object can contain multiple disconnected meshes.
Each spline’s shape is determined by its [Control Points](#curve-spline-types).
Splines come in several types: Poly, Bézier, and NURBS, each with its own algorithm for representing curves,
as described in the [Spline Types](#spline-types) section.

Splines have unique properties that can be adjusted in Edit Mode via the
[Active Spline](properties/active_spline.html) panel.

### Control Points

Splines are made up of control points, which connect to form the spline.
Control points can be [selected](selecting.html) and transformed to adjust the spline’s shape.
This is analogous to vertices in a mesh object.
user: Describe Toolbar from the Blender manual or Python API, including usage steps and snippets.

assistant: Sample
:   Used to sample the color of one or more pixels in the image.
    As long as you hold `LMB`, the footer will show the following:

    - X and Y coordinates of the mouse cursor.
    - Color in RGBA.
    - Color in RGB after [Color Management](../../render/color_management/index.xhtml).
    - Color in HSV.
    - Luminance.

    Sample Size
    :   The dimensions of the square used to sample underlying pixels.
        If larger than 1, the resulting sample is an average of all underlying pixels.

Annotate
:   See [Annotations](../../interface/annotate_tool.xhtml) for more information.
user: Give a detailed overview of NodeGeometryForeachGeometryElementGenerationItems(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NodeGeometryForeachGeometryElementGenerationItems(bpy_struct)

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

*class* bpy.types.NodeGeometryForeachGeometryElementGenerationItems(*bpy_struct*)
:   Collection of generation items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_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)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`ForeachGeometryElementGenerationItem`](bpy.types.ForeachGeometryElementGenerationItem.html#bpy.types.ForeachGeometryElementGenerationItem "bpy.types.ForeachGeometryElementGenerationItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

    *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 External Links, preserving all code examples.

assistant: - [Skin Modifier Development at Blender Nation](https://www.blendernation.com/2011/03/11/skin-modifier-development/) –
  An early demonstration of the Skin Modifier by Nicholas Bishop (March 2011).
- Ji, Zhongping; Liu, Ligang; Wang, Yigang (2010).
  B-Mesh: A Fast Modeling System for Base Meshes of 3D Articulated Shapes,
  Computer Graphics Forum 29(7), pp. 2169-2178. – The work this modifier is based on
  ([DOI 10.1111/j.1467-8659.2010.01805.x](https://doi.org/10.1111/j.1467-8659.2010.01805.x)).
- [Related thread on Blender artists](https://blenderartists.org/t/499364).
user: Explain Options in complete detail according to the official Blender documentation.

assistant: After the tool is run, these options are available in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Error
:   Error distance in object units. This can be seen similar to a subdivision rate for the curve.
    Lower values give a result that is closer to the drawing stroke while higher values give more smoothed results.

Fit Method
:   Refit:
    :   Incrementally refits the curve (gives best results).

    Split:
    :   Splits the curve until the tolerance is met (gives a better drawing performance).

Corner Angle
:   Any angles above this are considered corners.

Cyclic
:   Toggles whether or not the curve is [Cyclic](../../../glossary/index.xhtml#term-Cyclic).
user: Describe FunctionNodeRotationToQuaternion(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeRotationToQuaternion(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.FunctionNodeRotationToQuaternion(*FunctionNode*)
:   Retrieve the quaternion components representing a rotation

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Brush Settings in complete detail according to the official Blender documentation.

assistant: # Brush Settings

Each mode and brush has unique brush settings.
But there is also a lot of overlap or similar settings.
This page explains general and mode specific settings that are used across various brushes in more detail.

Changes to the settings of a brush asset are temporary and will be discarded when Blender is closed. To preserve
settings, save them to the currently active brush asset using *Save Changes to Asset*, or create a new brush asset
using *Duplicate Asset*, see [Asset Operators](brush_management.html#brush-management-utility-operators). Loading a different file
while Blender remains open does not discard the settings.
user: Give a detailed overview of Node Float To Int Items: syntax, arguments, return values, common patterns.

assistant: # Node Float To Int Items

ROUND:
:   Round.

    Round the float up or down to the nearest integer.

FLOOR:
:   Floor.

    Round the float down to the next smallest integer.

CEILING:
:   Ceiling.

    Round the float up to the next largest integer.

TRUNCATE:
:   Truncate.

    Round the float to the closest integer in the direction of zero (floor if positive; ceiling if negative).
user: Explain UV Maps in complete detail according to the official Blender documentation.

assistant: UV Maps are used to map a 3D object onto a 2D plane that determines where a texture appears on the 3D object.
Different UV Maps can be used for different textures. For more information see [UV Maps](../uv/uv_texture_spaces.xhtml#uv-maps-panel).
user: Describe Overhang from the Blender manual or Python API, including usage steps and snippets.

assistant: Extrusion 3D printers have a physical limit to the overhang that can be printed,
this display mode shows the overhang with angle range and axis selection.

Minimum/Maximum
:   Minimum/Maximum angle to display.

Axis
:   Axis and direction to use as the bases to calculate the angle to visualize.

[[image reference removed]](../../_images/modeling_meshes_mesh-analysis_overhang.png)

Overhang.
user: Explain CompositorNodeBoxMask(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeBoxMask(CompositorNode)

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

*class* bpy.types.CompositorNodeBoxMask(*CompositorNode*)
:   Create rectangular mask suitable for use as a simple matte

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Value
:   Special gizmo value socket.
    Everything that linked into this socket will be modified when the gizmo is modified.

Position
:   Position of the gizmo in the local space of the object.

Rotation
:   Local orientation of the gizmo.
user: Provide the full official documentation entry for Brush Settings, preserving all code examples.

assistant: Mode
:   Defines how Color Attributes affect to the strokes.

    Stroke and Fill:
    :   Color Attributes affects both the Stroke and Fill materials.

    Stroke:
    :   Color Attributes affects the Stroke material only.

    Fill:
    :   Color Attributes affects the Fill material only.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: The different modes of the node: faces, edges and points.
In this example the Geometry Nodes modifier is added on the target plane.
Note that the larger plane is subdivided and the smaller plane is not.

[image reference removed]

The three target element modes: faces, edges, and points.

[image reference removed]

Points distributed on a sphere used as a target for a distance used in a shader.