PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

Here, the *Count* mode of the [Resample Curve Node](../operations/resample_curve.xhtml) is recreated,
except a mesh is used for the result instead of a curve. The Z axis of the position can be used
as the sample factor because the position is between zero and one for the entire line.
user: What is FunctionNodeRotationToAxisAngle(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeRotationToAxisAngle(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.FunctionNodeRotationToAxisAngle(*FunctionNode*)
:   Convert a rotation to axis angle components

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

assistant: Geometry
:   The input geometry to be smoothed.

Selection
:   Controls which elements are affected by the smoothing operation.
    Unselected elements remain unchanged.

Iterations
:   The number of smoothing steps to perform.
    Higher values result in a stronger smoothing effect.

Weight
:   Relative mix weight of neighboring elements.
    Determines how strongly each element is influenced by the positions of its neighbors.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Invert
:   Invert the stabilization. If the stabilization calculated is to move the movie clip up by 5 units,
    this will move the movie clip down by 5 units.

### Sampling

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

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

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

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

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.
user: Explain NodeSocketVectorPercentage(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketVectorPercentage(NodeSocketStandard)

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

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

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Set Attribute in complete detail according to the official Blender documentation.

assistant: # Set Attribute

Opens a pop-up window showing the name of the [active](../../../../glossary/index.xhtml#term-Active) [attribute](../../../../glossary/index.xhtml#term-Attribute)
as well as the value of that attribute for the active element (vertex/edge/face).
From there, you can change the value to apply it to all selected elements.

The “active” attribute is the one last selected in the
[Data](../../properties/object_data.xhtml) tab of the [Properties Editor](../../../../editors/properties_editor.xhtml) editor.
It could be a [UV Map](../../uv/uv_texture_spaces.xhtml#uv-maps-panel),
a [Color Attribute](../../properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes),
or a generic [Attribute](../../../geometry_nodes/attributes_reference.xhtml).
user: Explain Shrink/Fatten in complete detail according to the official Blender documentation.

assistant: # Shrink/Fatten

Moves the selected vertices “inwards” or “outwards” along their normal,
all by the same distance. You can control this distance by moving the mouse up or down,
typing a number, or using the slider in the [Adjust Last Operation](../../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Even Thickness `S`, `Alt`
:   Applies a larger offset to vertices that are part of a sharp corner, for a more uniform result.
    You can toggle this option by pressing `S`, holding `Alt`, or clicking the
    checkbox in the Adjust Last Operation panel.

|  |  |  |
| --- | --- | --- |
| ../../../../../_images/modeling_meshes_editing_mesh_transform_shrink-fatten_before.png   Mesh before shrink/fatten. | ../../../../../_images/modeling_meshes_editing_mesh_transform_shrink-fatten_inflate-positive.png   Inflated using a positive value. | ../../../../../_images/modeling_meshes_editing_mesh_transform_shrink-fatten_inflate-negative.png   Shrunk using a negative value. |
user: Explain Vertex Groups for Particles in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../_images/sculpt-paint_weight-paint_usage_particles.png)

Weight painted particle emission.

By selecting vertex groups in the [Vertex Groups](../../physics/particles/emitter/vertex_groups.html)
panel of a [particle system](../../physics/particles/introduction.html)’s properties,
you can have different particle densities, hair lengths etc. across different areas of the mesh.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Limit Rotation constraint.

Limit X, Y, Z
:   The number fields determine the angle range for each axis.
    The checkboxes determine whether each range applies.

Order
:   The [Euler](../../../glossary/index.html#term-Euler) order to use when applying the limits.
    Defaults to the order of the owner, or XYZ if the owner uses a non-Euler
    rotation.

Affect Transform
:   When the owner is manually rotated, restrict not just its
    [visual](../introduction.html#constraint-visual-transform) rotation but also its
    *Rotation* in the [Properties Editor](../../../editors/properties_editor.html)’s *Transform* panel.

Legacy Behavior
:   For backwards compatibility: make the constraint behave in the semi-broken
    way it did prior to Blender 4.2. This old behavior does not properly account
    for the looping nature of rotations, and therefore causes
    unpredictable/erratic rotation snapping. However, this behavior can still be
    useful in some specific circumstances when Owner is set to *Local Space*, and
    some older rig setups utilize that. However, that behavior is better and more
    robustly accomplished with drivers directly on the object/bone’s rotation
    properties, so new rigs should favor that approach over using this option.

[Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The space for determining and limiting the rotation of the owner.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Describe Rotate Instances Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Rotate Instances Node

[image reference removed]

The *Rotate Instances* node rotates geometry instances in local or global space.

The [Instances](../instances.xhtml) page contains more information about geometry instances.
user: Show practical ways to work with ShaderNodeCombineColor(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeCombineColor(ShaderNode)

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

*class* bpy.types.ShaderNodeCombineColor(*ShaderNode*)
:   Create a color from individual components using multiple models

    mode
    :   Mode of color processing

        Type:
        :   enum in [Node Combsep Color Items](bpy_types_enum_items/node_combsep_color_items.html#rna-enum-node-combsep-color-items), default `'RGB'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Film

Exposure
:   This can be used to change the brightness of an image.
    Different than the *Exposure* option found in the [Color management](../../color_management/displays_views.html#render-post-color-management) panel,
    this exposure option works *on the data* while the Color management exposure is on the *view transform*.
user: What is MeshEdge(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MeshEdge(bpy_struct)

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

*class* bpy.types.MeshEdge(*bpy_struct*)
:   Edge in a Mesh data-block

    hide
    :   Type:
        :   boolean, default False

    index
    :   Index of this edge

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

    is_loose
    :   Edge is not connected to any faces

        Type:
        :   boolean, default False, (readonly)

    select
    :   Type:
        :   boolean, default False

    use_edge_sharp
    :   Sharp edge for shading

        Type:
        :   boolean, default False

    use_seam
    :   Seam edge for UV unwrapping

        Type:
        :   boolean, default False

    vertices
    :   Vertex indices

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

    key
    :   (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain ObjectConstraints(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ObjectConstraints(bpy_struct)

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

*class* bpy.types.ObjectConstraints(*bpy_struct*)
:   Collection of object constraints

    active
    :   Active Object constraint

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

    new(*type*)
    :   Add a new constraint to this object

        Parameters:
        :   **type** (enum in [Constraint Type Items](bpy_types_enum_items/constraint_type_items.html#rna-enum-constraint-type-items)) – Constraint type to add

        Returns:
        :   New constraint

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

    remove(*constraint*)
    :   Remove a constraint from this object

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Removed constraint

    clear()
    :   Remove all constraint from this object

    move(*from_index*, *to_index*)
    :   Move a constraint to a different position

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

    copy(*constraint*)
    :   Add a new constraint that is a copy of the given one

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Constraint to copy - may belong to a different object

        Returns:
        :   New constraint

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

    *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 Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Once an armature is [skinned](../skinning/index.xhtml) by the needed object(s),
you need a way to configure the armature into positions known as poses.
Basically, by transforming the bones, you deform or transform the skinned object(s).
However, you will notice that you cannot do this in *Edit Mode* –
remember that *Edit Mode* is used to edit the default, base, or “rest” position of an armature.
You may also notice that you cannot use *Object Mode* either, as here you can only transform whole objects.

So, armatures have a third mode dedicated to the process of posing known as *Pose Mode*.
In rest position (as edited in *Edit Mode*), each bone has its own position/rotation/scale to neutral values
(i.e. 0.0 for position and rotation, and 1.0 for scale). Hence, when you edit a bone in *Pose Mode*,
you create an offset in the transform properties, from its rest position.
This may seem quite similar if you have worked with [relative shape keys](../../shape_keys/index.xhtml)
or [Delta Transformations](../../../scene_layout/object/properties/transforms.xhtml#bpy-types-object-delta).

Even though it might be used for completely static purposes,
posing is heavily connected with animation features and techniques.
So if you are not familiar at all with animation in Blender,
it might be a good idea to read the [animation chapter](../../index.xhtml) first,
and then come back here.
user: Show practical ways to work with Combine Spherical Node in a Blender add-on or script – include code.

assistant: # Combine Spherical Node

[image reference removed]

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

Spherical coordinates represent a point in 3D space by its distance from the origin,
horizontal rotation, and vertical inclination, which can be useful for constructing
radial or rotational patterns and generating coordinates on a sphere.
user: How do I use Accessing Brushes in Blender? Include parameters, examples, warnings and best practices.

assistant: In modes that use painting or sculpting functionality, the [Asset Shelf](../../interface/window_system/regions.html#ui-region-asset-shelf) of the 3D
Viewport and Image Editor displays brush assets that can be used in that mode. Clicking a brush asset will activate
the Brush Tool if necessary, with the clicked brush set.

[image reference removed]

The Asset Shelf of the 3D Viewport, providing access to brush assets.

This asset shelf is also available as popup in the [Tool Settings](../../interface/window_system/regions.html#ui-region-tool-settings), the
[Sidebar](../../interface/window_system/regions.html#ui-region-sidebar), [Properties](../../editors/properties_editor.html) and using a shortcut.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Dynamic paint is a modifier and physics system that can turn objects into paint canvases
and brushes, creating Color Attributes, image sequences, or displacement.
This makes many effects possible like, for example footsteps in the snow,
raindrops that make the ground wet, paint that sticks to walls, or objects that gradually freeze.
user: Describe System Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Reload Scripts

Reloads all scripts found in the scripts data folder;
any changes that have been made in the Text Editor will be lost!

### Memory Statistics

This operator which can be found by searching “Memory Statistics”
with the [Operator Search](../interface/operators.xhtml#bpy-ops-wm-search-operator)
will print useful information about memory objects, their size and user count.

### Debug Menu

This operator brings up a menu to set Blender into a certain debug mode.

See the
[source code](https://projects.blender.org/blender/blender/src/branch/main/source/blender/blenkernel/BKE_global.hh)
for a description of what each value does.

### Redraw Timer

This operator brings up a menu with a list of tests
to benchmark UI render times along with undo/redo functions.

### Clean Up Space-Data

Removes unused settings for invisible editors.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: A, B
:   Standard value inputs of the selected type.

C
:   Compared against the dot product of two input vectors in when the *Mode* property is set to *Dot Product*.

Epsilon
:   This value is used as a threshold for still considering the two inputs as equal
    for the Equal and Not Equal operations.
user: Explain Clamp Fireflies in complete detail according to the official Blender documentation.

assistant: Ideally with all the previous tricks, [Fireflies](../../../glossary/index.xhtml#term-Fireflies) would be eliminated, but they could still happen.
For that, the *intensity* that any individual light ray sample will contribute to a pixel can be *clamped*
to a maximum value with the integrator [Clamp setting](../render_settings/light_paths.xhtml#render-cycles-integrator-clamp-samples).

If set too low this can cause missing highlights in the image,
which might be useful to preserve for camera effects such as bloom or glare.
To mitigate this conundrum it’s often useful to clamp only indirect bounces,
leaving highlights directly visible to the camera untouched.

|  |  |
| --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_no-clamp.jpg   No Clamp (0). | ../../../_images/render_cycles_optimizations_reducing-noise_clamp4.jpg   With Clamp set to 4. |
user: Explain MaintainVolumeConstraint(Constraint) in complete detail according to the official Blender documentation.

assistant: # MaintainVolumeConstraint(Constraint)

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

*class* bpy.types.MaintainVolumeConstraint(*Constraint*)
:   Maintain a constant volume along a single scaling axis

    free_axis
    :   The free scaling axis of the object

        Type:
        :   enum in [`'SAMEVOL_X'`, `'SAMEVOL_Y'`, `'SAMEVOL_Z'`], default `'SAMEVOL_X'`

    mode
    :   The way the constraint treats original non-free axis scaling

        - `STRICT`
          Strict – Volume is strictly preserved, overriding the scaling of non-free axes.
        - `UNIFORM`
          Uniform – Volume is preserved when the object is scaled uniformly. Deviations from uniform scale on non-free axes are passed through..
        - `SINGLE_AXIS`
          Single Axis – Volume is preserved when the object is scaled only on the free axis. Non-free axis scaling is passed through..

        Type:
        :   enum in [`'STRICT'`, `'UNIFORM'`, `'SINGLE_AXIS'`], default `'STRICT'`

    volume
    :   Volume of the bone at rest

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`IKParam.ik_solver`](bpy.types.IKParam.html#bpy.types.IKParam.ik_solver "bpy.types.IKParam.ik_solver") |
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: - Use the *Shape Key Editor* to keyframe shape key influences over time.
- Adjust timing by moving or scaling keyframes directly in the timeline.
- Combine with other Dope Sheet modes (such as the *Action Editor*) for complex character animation workflows.

See also: [Shape Key Basics](../../../animation/shape_keys/introduction.xhtml) for details on creating
and managing shape keys.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

The Simplify modifier.

Mode
:   Determines how to reduce points in the strokes.

    Fixed:
    :   Deletes alternated points in the strokes, except the start and end points.

        Iterations
        :   Number of times to repeat the procedure.

    Adaptive:
    :   Uses the RDP algorithm (Ramer-Douglas-Peucker algorithm) for points deletion.
        The algorithm try to obtain a similar line shape with fewer points.

        Factor
        :   Controls the amount of recursively simplifications applied by the algorithm.

    Sample:
    :   Recreates the stroke geometry with a predefined length between points.

        Length
        :   The distance between points on the recreated stroke.
            Smaller values will require more points to recreate the stroke,
            while larger values will result in fewer points needed to recreate the curve.

        Sharp Threshold
        :   Preserve corners that have sharper angle than this threshold.

    Merge:
    :   Simplifies the strokes by merging points that are closer than a specified distance to each other.

        Distance
        :   Sets the distance threshold for merging points.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Grease Pencil, preserving all code examples.

assistant: Converts the selected curve, mesh, or text object to a Grease Pencil object, generating strokes
that follow the original shape. Basic materials are also created.
When multiple objects are selected, they are combined into a single Grease Pencil object.

Keep Original
:   Keeps the original object by creating a duplicate before conversion.

Thickness
:   Defines the stroke thickness.

Stroke Offset
:   Adjusts the offset to separate strokes from filled areas.

Export Faces
:   Converts mesh faces into filled strokes.
user: What is BoneColor(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BoneColor(bpy_struct)

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

*class* bpy.types.BoneColor(*bpy_struct*)
:   Theme color or custom color of a bone

    custom
    :   The custom bone colors, used when palette is ‘CUSTOM’

        Type:
        :   [`ThemeBoneColorSet`](bpy.types.ThemeBoneColorSet.html#bpy.types.ThemeBoneColorSet "bpy.types.ThemeBoneColorSet"), (readonly, never None)

    is_custom
    :   A color palette is user-defined, instead of using a theme-defined one

        Type:
        :   boolean, default False, (readonly)

    palette
    :   Color palette to use

        Type:
        :   enum in [`'DEFAULT'`, `'THEME01'`, `'THEME02'`, `'THEME03'`, `'THEME04'`, `'THEME05'`, `'THEME06'`, `'THEME07'`, `'THEME08'`, `'THEME09'`, `'THEME10'`, `'THEME11'`, `'THEME12'`, `'THEME13'`, `'THEME14'`, `'THEME15'`, `'THEME16'`, `'THEME17'`, `'THEME18'`, `'THEME19'`, `'THEME20'`, `'CUSTOM'`], default `'DEFAULT'`

    *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 Closure in Blender? Include parameters, examples, warnings and best practices.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.html) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Explain Display Settings in complete detail according to the official Blender documentation.

assistant: The mask display can be toggled as a [viewport overlay](../../../editors/3dview/display/overlays.html).
In the overlay popover, the opacity of the mask overlay can be adjusted to make it more or less visible on the mesh.
user: Describe NodeTreeInterfaceSocketMaterial(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

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

assistant: [image reference removed]

Lattice Modifier.

Object
:   The [Lattice](../../../animation/lattice.xhtml) object with which to deform the base object.

Strength
:   A factor to control blending between original and deformed points positions.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Raycast Node, preserving all code examples.

assistant: # Raycast Node

[image reference removed]

The *Raycast* node intersects rays from one geometry onto another. The source geometry is defined by
the context of the node that the *Raycast* node is connected to.
Each ray computes hit points on the target mesh and outputs normals, distances
and any surface attribute specified.
user: Provide the full official documentation entry for Subsurface Scattering, preserving all code examples.

assistant: # Subsurface Scattering

[image reference removed]

The *Subsurface Scattering* node is used to add simple subsurface multiple scattering,
for materials such as skin, wax, marble, milk and others. For these materials,
rather than light being reflect directly off the surface, it will penetrate the surface and
bounce around internally before getting absorbed or leaving the surface at a nearby point.

How far the color scatters on average can be configured per RGB color channel. For example,
for skin, red colors scatter further, which gives distinctive red-colored shadows,
and a soft appearance.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Grease Pencil is a Blender object. It accepts the drawing information
from a mouse or pressure-sensitive stylus and places it in 3D space
as a collection of points, which are defined as a stroke.

The Grease Pencil object can be used to make traditional 2D animation, cut-out animation,
motion graphics, or used it as storyboard tool, among other things.

[image reference removed]

An illustration in 3D space using the Grease Pencil object.

Strokes are created in [Draw Mode](modes/draw/introduction.xhtml),
which requires a new [keyframe](../animation/keyframes/editing.xhtml)
in the animation timeline for the Grease Pencil object.
Existing strokes can then be adjusted in [Edit Mode](modes/edit/introduction.xhtml)
and [Sculpt Mode](modes/sculpting/introduction.xhtml).
Finally, artists can apply materials, modifiers, lighting, and visual effects to strokes.
user: Describe NodeFrame(NodeInternal) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeFrame(NodeInternal)

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

*class* bpy.types.NodeFrame(*NodeInternal*)
:   Collect related nodes together in a common area. Useful for organization when the re-usability of a node group is not required

    label_size
    :   Font size to use for displaying the label

        Type:
        :   int in [8, 64], default 0

    shrink
    :   Shrink the frame to minimal bounding box

        Type:
        :   boolean, default False

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

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

assistant: What one can see on the screen after rendering is called the *Front Buffer*.
When draw calls are issued, batches are drawn on a *Back Buffer* that will only be displayed
when all drawing is done and the current back buffer will become the new front buffer.
Sometimes, one might want to draw the batches into a distinct buffer that could be used as
texture to display on another object or to be saved as image on disk.
This is called Offscreen Rendering.
In Blender Offscreen Rendering is done using the [`gpu.types.GPUOffScreen`](gpu.types.html#gpu.types.GPUOffScreen "gpu.types.GPUOffScreen") type.
user: Give a detailed overview of Animation Options: syntax, arguments, return values, common patterns.

assistant: ### Draw Mode

In Draw Mode there are three options related to the animation workflow that you can use.

[image reference removed]

General drawing/animation options.

Add Weight Data
:   When enabled, new strokes weight data is added according to the current vertex group and weights.
    If there is no vertex group selected, no weight data is added.

    This is useful for example in cut-out animation for adding new drawing
    on the same vertex group without the need to creating it afterwards.

    See [Weight Paint Mode](../modes/weight_paint/introduction.html) for more information.

Additive Drawing
:   When creating new frames, the strokes from the previous/active frame are include as a basis for the new one.

Multiframe
:   If you need to add new strokes to your animation on several frames you can use multiframe drawing.

    You can activate multiframe drawing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../multiframe.html) for more information.

### Edit Mode

In Edit Mode there is an option related to the animation workflow that you can use.

[image reference removed]

Multiframe editing.

Multiframe
:   Sometimes you may need to modify several frames at the same time with edit tools,
    for example to repositioning drawings in an animation.

    You can activate multiframe editing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../multiframe.html) for more information.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Brushes are the main way of interacting with any painting and sculpting mode. By click & dragging in the 3D Viewport
(or the Image Editor when using [Texture Paint](../texture_paint/index.xhtml)), the active brush creates a
[stroke](stroke.xhtml) with a certain effect, depending on the used brush settings. Brushes are
used as brush assets and stored in asset libraries, which makes it easy to reuse and share them. Typically they have a
preview image and a name that indicate the effect they create.
user: How do I use With Automatic Weights in Blender? Include parameters, examples, warnings and best practices.

assistant: *With Automatic Weights* parenting works similar to *With Empty Groups*,
but it will not leave the vertex groups empty. It calculates how much influence a particular bone
would have on vertices based on the distance from those vertices to a particular bone (“bone heat” algorithm).
This influence will be assigned as weights in the vertex groups.

This method of parenting is certainly easier to setup, but it can often lead to armatures which do not deform child
objects in ways you would want. Overlaps can occur when it comes to determining which bones should
influence certain vertices when calculating influences for more complex armatures and child objects.
Symptoms of this confusion are that when transforming the armature in *Pose Mode*,
parts of the child objects do not deform as you expect;
If Blender does not give you the results you require,
you will have to manually alter the weights of vertices in relation to the vertex groups they belong to and
have influence in.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: As the modifier is only a container its actual options can be configured in the *Physics Properties* tab.
See the [Collision Physics Properties](../../../physics/cloth/settings/index.xhtml) for more information.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

The Vertex Weight Angle modifier panel.

Vertex Group
:   The vertex group to affect.

    Invert
    :   Inverts the influence of the selected vertex group. The setting reverses the weight values of the group.

Angle
:   Sets the angle for the maximum weights value.

Axis
:   The axis along which the angle affects the weights.

    X, Y, Z

Space
:   Coordinate space to be used.

Minimum
:   Minimum value for vertex weight.

Multiply Weights
:   Multiply the calculated weights with the existing values in the vertex group.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

### Unique

Deformation
:   Deformation type that is used by the brush.

    Bend:
    :   Rotates the boundary around the local Y axis.
        Useful for creating folding shapes, like sleeves.

    Expand:
    :   Moves/extends the mesh boundary in the local X direction.
        Useful for extending the boundaries along the surface.

    Inflate:
    :   Works similar to the [Inflate](inflate.html) tool but,
        the vertices that are inflated are constrained to the mesh boundary.

    Grab:
    :   Works similar to the [Grab](grab.html) tool but,
        the vertices that are grabbed are constrained to the mesh boundary.

    Twist:
    :   Rotates the active boundary around the local Z axis.
        Useful for creating folds like on a skirt.

    Smooth:
    :   Works similar to the [Grab](smooth.html) tool but,
        the vertices that are smoothed are constrained to the mesh boundary.

Boundary Falloff
:   How the brush [Falloff](../../brush/falloff.html) is applied across the boundary.

    Constant:
    :   Applies the same deformation in the entire boundary.

    Brush Radius:
    :   Applies the deformation only within the brush radius.

    Loop:
    :   Applies the brush falloff in a loop pattern along the boundary.

    Loop and Invert:
    :   Applies the falloff radius in a loop pattern,
        inverting the direction back & forth.

Boundary Origin Offset
:   Offset of the boundary origin in relation to the brush radius.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Output
:   Outputs the value from the input corresponding to the current *Index* value,
    without any modification.
    If the *Index* value is outside the range of available inputs, the output defaults
    to the first input or a zero-equivalent value, depending on the data type.
user: Show practical ways to work with Action Track in a Blender add-on or script – include code.

assistant: The topmost track with the orange header holds the action that’s being edited. Normally this is the
object’s active action, but if you select a strip and press `Tab` to enter Tweak Mode,
you can temporarily make that one editable instead –
in the [Action Editor](../dope_sheet/modes/action.xhtml)
or the [Graph Editor](../graph_editor/introduction.xhtml), for example.

The Action Track has one of the following buttons:

Push Down Action
:   Not available in Tweak Mode. Creates a new track below the Action Track and moves the active action
    into it as a strip, leaving the Action Track empty. (If you create a keyframe after this,
    Blender will automatically create a new active action to hold it.)

    [image reference removed]

    Push Down Action button.

Pin
:   Only available in Tweak Mode. When unchecked, the action’s keyframes are shown at their original
    time points, rather than their new time points resulting from the strip being moved and scaled.

    [image reference removed]

    Strip at its original time point.

    [image reference removed]

    Strip moved. Notice that the keyframes are now shown to start at frame 20, which is also
    how the animation will behave. Within the action, however, they still start at frame 1.

    [image reference removed]

    After unchecking the Pin icon, the keyframes are shown at their original time points.
user: Describe IDPropertyWrapPtr(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # IDPropertyWrapPtr(bpy_struct)

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

*class* bpy.types.IDPropertyWrapPtr(*bpy_struct*)
:   bl_system_properties_get(*\**, *do_create=False*)
    :   DEBUG ONLY. Internal access to runtime-defined RNA data storage, intended solely for testing and debugging purposes. Do not access it in regular scripting work, and in particular, do not assume that it contains writable data

        Parameters:
        :   **do_create** (*boolean**,* *(**optional**)*) – Ensure that system properties are created if they do not exist yet

        Returns:
        :   The system properties root container, or None if there are no system properties stored in this data yet, and its creation was not requested

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

    *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