PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Intersect (Boolean) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Intersect (Boolean)

Performs Boolean operations between the selected and unselected geometry.

[image reference removed]

Selecting a sphere and performing an Intersection, Union, and Difference
with a cube.

The [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel offers the following options:

Boolean Operation
:   Intersect:
    :   Only keep the volume that’s inside both the selected and the unselected geometry.

    Union:
    :   Remove the interior faces between the selected and the unselected geometry.

    Difference:
    :   Cut the selected geometry out of the unselected geometry, then remove the selected geometry.

Solver
:   Algorithm used to perform the Boolean operation.

    Float:
    :   Uses a simple solver which offers the good performance;
        however, this solver lacks support for overlapping geometry.

        Merge Threshold
        :   Tolerance for close faces to be considered touching.
            It may be useful to increase this when some intersections aren’t detected that should be and
            when extra geometry is being created because edges aren’t detected as overlapping.

    Exact:
    :   Uses a complex solver which offers the best results and has full
        support for overlapping geometry; however, this solver is much slower.

Swap
:   When using *Difference*, cut the unselected geometry out of the selected geometry instead
    of the other way around.

Self Intersection
:   Correctly handle self-intersection in the participating geometry, at the cost of performance.
user: Explain Decimate Geometry in complete detail according to the official Blender documentation.

assistant: Reduces the face count of the selected geometry while minimizing shape changes.

Ratio
:   The target triangle count ratio. For example, enter 0.4 to keep collapsing edges
    until the triangle count is 40% of the original.

Vertex Group
:   Use the active vertex group when choosing which edges to collapse.
    The higher the vertex weights for an edge, the more likely it is to be chosen,
    even taking priority over “better” (shorter) candidates.

    Weight
    :   Factor by which to multiply the vertex weights.

    Invert
    :   Inverts the vertex weights, making edges with *lower* weights get collapsed first.

Symmetry
:   Maintain symmetry on either the *X*, *Y*, or *Z* axis.
user: Provide the full official documentation entry for ShaderFxWave(ShaderFx), preserving all code examples.

assistant: # ShaderFxWave(ShaderFx)

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

*class* bpy.types.ShaderFxWave(*ShaderFx*)
:   Wave Deformation effect

    amplitude
    :   Amplitude of Wave

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

    orientation
    :   Direction of the wave

        Type:
        :   enum in [`'HORIZONTAL'`, `'VERTICAL'`], default `'HORIZONTAL'`

    period
    :   Period of Wave

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

    phase
    :   Phase Shift of Wave

        Type:
        :   float in [-inf, 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: Provide the full official documentation entry for Gizmos, preserving all code examples.

assistant: The *Split* node provides an interactive gizmo in the Node Editor.
To enable it, make sure [Active Node Gizmo](../../../editors/compositor.xhtml#bpy-types-spacenodeeditor-show-gizmo-active-node)
is turned on, then select the *Split* node.

The gizmo displays a split line with draggable handles:

- Drag the line to adjust the split *position* horizontally or vertically.
- Use the circular handle at the center to adjust the *rotation* interactively.
user: Explain Bpy.Types.Greasepencilenvelopemodifier in complete detail according to the official Blender documentation.

assistant: sePencilEnvelopeModifier.use_layer_group_filter GreasePencilEnvelopeModifier.use_layer_pass_filter GreasePencilEnvelopeModifier.use_material_pass_filter GreasePencilEnvelopeModifier.vertex_group_name GreasePencilEnvelopeModifier.bl_rna_get_subclass() GreasePencilEnvelopeModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Provide the full official documentation entry for Transform, preserving all code examples.

assistant: Tools for moving control points.

Move, Rotate, Scale
:   See [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml).

To Sphere, Shear, Bend, Push/Pull, Warp, Randomize
:   See [Mesh Transformations](../../meshes/editing/mesh/transform/index.xhtml).

Move/Scale Texture Space
:   See [Texture Space](../../meshes/uv/uv_texture_spaces.xhtml#properties-texture-space).
user: How do I use Line Art Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Line Art Modifier

The *Line Art* modifier generates stylized Line Art from a scene, collection, or object.

In order for the effects of the modifier to be visible, the scene must have an active camera.
The generated lines are only generated on portions of the object that a visible from this camera.
user: Describe Relocate Linked ID from the Blender manual or Python API, including usage steps and snippets.

assistant: A right-click a linked ID will show the *Relocate* option in the *ID Data* sub-menu. It allows to
relocate a directly linked ID by another one, from the same library or from a different one.
This can be used to either fix a broken linked data-block (e.g. because the ID was renamed),
or to switch to a variation of the same data.
user: Provide the full official documentation entry for Adaptive Subdivision, preserving all code examples.

assistant: Cycles Only

Adaptive Subdivision
:   Subdivide objects based on their distance to the camera, automatically adding more or less
    detail. Particularly useful for fine displacement detail.

Adaptive Space
:   Pixel:
    :   Subdivide polygons to reach a specified pixel size on screen.

    Object:
    :   Subdivide to reach a specified edge length in object space. This is required to use
        adaptive subdivision for instanced meshes.

Pixel Size
:   Target polygon pixel size for adaptive subdivision.

Edge Length
:   Target object space edge length.

### Limitations

- Multi-view renders can have some inconsistencies between views.
- Instancing does not work well with Pixel space subdivision. Subdivision will be
  based on the original object position relative to the camera, and it is recommended
  to use Object space instead.
user: Provide the full official documentation entry for Clip Display, preserving all code examples.

assistant: # Clip Display

This pop-over contains various display settings for both Tracking mode and Mask mode.

R, G, B
:   Controls the color channels used for the frame preview. The tracking algorithm works with grayscale images,
    and with these options, you can check which combination of enabled and disabled channels will yield
    the best contrast and the least noise.

    Note that this only affects the preview. To select which channels to use for the actual tracking,
    use the [Track tab in the Toolbar](../../../movie_clip/tracking/clip/toolbar/track.xhtml) to set a default
    for newly created markers, or the [Track tab in the Sidebar](../../../movie_clip/tracking/clip/sidebar/track/track.xhtml)
    to configure existing markers.

Grayscale Preview (B/W)
:   Shows the whole frame as a grayscale image.

Mute Footage `M`
:   Hides the movie clip and displays a black image instead.
    This helps to find markers that are tracked inaccurately or not at all.

Render Undistorted
:   Applies the [Lens settings](../../../movie_clip/tracking/clip/sidebar/track/camera.xhtml#motion-tracking-camera-lens) to the
    video preview to undo lens distortion. Does not change the footage itself.

Show Stable
:   Applies the [2D stabilization](../../../movie_clip/tracking/clip/sidebar/stabilization/introduction.xhtml)
    settings to the video preview. Does not change the footage itself.

Grid
:   Displays a grid which is originally orthographic, but is distorted by the Lens settings.
    This can be used for manual calibration: the distorted grid lines should match lines
    in the footage that are meant to be straight.

Calibration
:   Applies the Lens settings to annotation strokes.
    Like the Grid, this option also helps to perform manual calibration.

Display Aspect Ratio
:   Changes the aspect ratio for displaying only. It does not affect the tracking or solving process.
user: Give a detailed overview of Spiral Node: syntax, arguments, return values, common patterns.

assistant: # Spiral Node

[image reference removed]

The *Spiral* node generates a poly spline in a spiral shape.
It can be used to create springs or other similar objects.
By default the spiral twists in a clockwise fashion.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Mesh
:   Standard geometry output.

Top
:   A boolean attribute field with a selection of the faces on the top of the cylinder. If the *Fill Type*
    property is *None*, then this will be a selection of the top edges instead. If the *Radius* is
    zero, this will be a selection of the top point.

Side
:   A boolean attribute field with a selection of the faces on the side of the cylinder.

Bottom
:   This is the same as the *Top* selection output, but on the bottom side of the geometry instead.

UV Map
:   A 2D vector representing the default X/Y coordinates of the [UV Map](../../../../glossary/index.html#term-UV-Map) for the primitive’s shape.
    This can be connected to the [Store Named Attribute Node](../../attribute/store_named_attribute.html),
    to be used once the Geometry Nodes Modifier get applied.
    The UV map must be stored on the face corner in order to be accessed.
user: Explain Match String Node in complete detail according to the official Blender documentation.

assistant: # Match String Node

[image reference removed]

The *Match String* node compares two string values and outputs a Boolean result based on the selected operation.
It is useful for conditional logic involving string comparisons, such as matching object names or attribute values.
user: Describe ChildParticle(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ChildParticle(bpy_struct)

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

*class* bpy.types.ChildParticle(*bpy_struct*)
:   Child particle interpolated from simulated or edited particles

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

assistant: Tablet API (Windows only)
:   Select the native Windows Ink or older Wintab system for pressure sensitivity.
    Blender automatically selects the API for your operating system and tablet,
    however in case of problems this can be set manually.
    You may need to restart Blender for changes to take affect.

Max Threshold
:   Amount of pressure required to achieve full intensity.

Softness
:   Controls how the softness of the low pressure response onset using a gamma curve.
user: Show practical ways to work with Damped Track Constraint in a Blender add-on or script – include code.

assistant: # Damped Track Constraint

The *Damped Track* constraint makes an object or bone point towards a certain target.
It’s typically called “Look At” or “Aim” in other 3D software.

The word “damped” means that the constraint uses a pure [swing](../../../glossary/index.xhtml#term-Swing) rotation
to minimize rolling around the tracking axis. This is in contrast to the
[Track To Constraint](track_to.xhtml) which applies an “Up” axis
in addition to the tracking.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Blend
:   The Blend modes can be selected in the select menu.
    See [Color Blend Modes](../../../../../glossary/index.html#term-Color-Blend-Modes) for details on each blending mode.

    Add, Subtract, Multiply, Screen, Divide, Difference,
    Darken, Lighten, Overlay, Color Dodge, Color Burn,
    Hue, Saturation, Value, Color, Soft Light, Linear Light

Opacity
:   The amount of the blend of the second image gets composed onto the first.
user: Show practical ways to work with Object Mode List in a Blender add-on or script – include code.

assistant: Blender’s Modes

| Icon | Name | Details |
| --- | --- | --- |
|  | [Object Mode](../../scene_layout/object/index.html) | The default mode, available for all object types. Allows editing position, rotation and scale, duplicating objects, and so on. |
|  | [Edit Mode](../../modeling/index.html) | A mode for editing an object’s shape (vertices/edges/faces for meshes, control points for curves/surfaces, points/strokes for Grease Pencil, etc.). |
|  | [Sculpt Mode](../../sculpt_paint/sculpting/index.html) | Provides an alternative toolset for editing an object’s shape (only for meshes). |
|  | [Vertex Paint Mode](../../sculpt_paint/vertex_paint/index.html) | A mesh-only mode that allows you to set your mesh’s vertex colors (i.e. to “paint” them). |
|  | [Weight Paint Mode](../../sculpt_paint/weight_paint/index.html) | A mesh-only mode, dedicated to vertex group weighting. |
|  | [Texture Paint Mode](../../sculpt_paint/texture_paint/index.html) | A mesh-only mode that allows you to paint a texture directly on the model, in the 3D Viewport. |
|  | [Particle Edit Mode](../../physics/particles/mode.html) | A mesh-only mode dedicated to particle systems, useful for editable systems (hair). |
|  | [Pose Mode](../../animation/armatures/posing/index.html) | An armature-only mode, dedicated to posing. |
|  | [Draw Mode](../../grease_pencil/modes/draw/index.html) | A Grease Pencil-only mode, dedicated to creating Grease Pencil strokes. |
|  | [Sculpt Mode (Grease Pencil)](../../grease_pencil/modes/sculpting/index.html) | A Grease Pencil-only mode, used to deform and shape existing strokes more organically. |
|  | [Edit Mode (Grease Pencil)](../../grease_pencil/modes/edit/index.html) | A Grease Pencil-only mode, dedicated to modifying individual strokes and points of Grease Pencil objects. |
|  | [Vertex Paint Mode (Grease Pencil)](../../grease_pencil/modes/vertex_paint/index.html) | A Grease Pencil-only mode, dedicated to adding color the vertices of strokes directly. |
|  | [Weight Paint Mode (Grease Pencil)](../../grease_pencil/modes/weight_paint/index.html) | A Grease Pencil-only mode, dedicated to assigning vertex weights to stroke. |

We will not go into any more detail on mode usages here,
because they are dealt with in their own sections.
user: Give a detailed overview of NodeSocketVectorVelocity2D(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketVectorVelocity2D(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.NodeSocketVectorVelocity2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Rotate: syntax, arguments, return values, common patterns.

assistant: # Rotate

Rotation is also known as a spin, twist, orbit, pivot, revolve, or roll and
involves changing the orientation of elements (vertices, edges, faces, objects, etc.)
around one or more axes or
the [Pivot Point](../../../../editors/3dview/controls/pivot_point/index.html).

The angle of rotation is displayed in the header of the 3D Viewport.

[image reference removed]

Rotation values.
user: How do I use ShaderNodeBsdfRefraction(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeBsdfRefraction(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.ShaderNodeBsdfRefraction(*ShaderNode*)
:   Glossy refraction with sharp or microfacet distribution, typically used for materials that transmit light

    distribution
    :   Light scattering distribution on rough surface

        Type:
        :   enum in [`'BECKMANN'`, `'GGX'`], default `'BECKMANN'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Controls, preserving all code examples.

assistant: Sculpt mode provides several properties that give advanced control of the tool’s behavior.
These options can be found in the right-hand side of the 3D Viewport’s Header.

Mirror
:   Allows tools to affect curves symmetrically according to the chosen axis.

Use Sculpt Collision
:   Prevents the curve segments from passing through the [Surface Object](../../modeling/curves_new/properties.xhtml#bpy-types-curves-surface).
user: What is Paste and how is it used in Blender Python scripting?

assistant: Paste Grease Pencil points or strokes from the internal clipboard to the active layer.

Paste on Back `Shift`-`Ctrl`-`V`
:   Add pasted strokes behind all strokes.

Keep World Transform
:   Keep the world transform of strokes from the clipboard unchanged.
user: Provide the full official documentation entry for Rigid Body Properties, preserving all code examples.

assistant: # Rigid Body Properties

Type
:   Role of the rigid body in the simulation.

    Active:
    :   The object is dynamic and is directly controlled by simulation results.

    Passive:
    :   The object remains static and is directly controlled by animation system,
        thus does not have [Dynamics](dynamics.xhtml) properties.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: The inputs are dynamic, they become available if needed depending on the node properties.

Vector
:   Texture coordinate to evaluate the noise at;
    defaults to *Generated* texture coordinates if the socket is left unconnected.

W
:   Texture coordinate to evaluate the noise at.

Scale
:   Scale of the noise.

Detail
:   Number of noise octaves.
    The fractional part of the input is multiplied by the magnitude of the highest octave.
    Higher number of octaves corresponds to a higher evaluation time.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Lacunarity
:   The difference between the scale of each two consecutive octaves.
    Larger values corresponds to larger scale for higher octaves.

Smoothness
:   The smoothness of the noise.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-zero.png   Smoothness: 0.0. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-quarter.png   Smoothness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-half.png   Smoothness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-one.png   Smoothness: 1.0. |
    | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-zero.png   Smoothness: 0.0. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-quarter.png   Smoothness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-half.png   Smoothness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-one.png   Smoothness: 1.0. |

Exponent
:   Exponent of the Minkowski distance metric.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-half.png   Exponent: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-one.png   Exponent: 1.0. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-two.png   Exponent: 2.0. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-32.png   Exponent: 32.0. |

Randomness
:   The randomness of the noise.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_randomness-one.png   Randomness: 1.0. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-half.png   Randomness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-quarter.png   Randomness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-zero.png   Randomness: 0.0. |
user: Give a detailed overview of Rotate Hair Curves: syntax, arguments, return values, common patterns.

assistant: # Rotate Hair Curves

The *Rotate Hair Curves* node twists or rotates each hair curve around a chosen axis,
allowing for effects such as gentle twisting, spiral motion, or directional flow in grooms.
It can be used to add subtle styling variation or create complex twisting deformations.
user: How do I use Player Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Ping Pong
:   When enabled, playback loops forwards than backwards.

X/Y Flip
:   Flip the image horizontally or vertically.

    *Viewing the animation from a different perspective can help you see the animation with “fresh eyes”.*
user: What is Object Empty Drawtype Items and how is it used in Blender Python scripting?

assistant: # Object Empty Drawtype Items

PLAIN_AXES:
:   Plain Axes.

ARROWS:
:   Arrows.

SINGLE_ARROW:
:   Single Arrow.

CIRCLE:
:   Circle.

CUBE:
:   Cube.

SPHERE:
:   Sphere.

CONE:
:   Cone.

IMAGE:
:   Image.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeRepeatOutput.repeat_items`](bpy.types.GeometryNodeRepeatOutput.html#bpy.types.GeometryNodeRepeatOutput.repeat_items "bpy.types.GeometryNodeRepeatOutput.repeat_items") |  |
user: Describe Annotation Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: The annotation tool can be activated in the Toolbar and has the following sub-tools:

Annotate
:   Draw free-hand strokes in the main area.

Annotate Line
:   Click and drag to create a line.
    Optionally, you can select the arrow style for the start and end of the line.

Annotate Polygon
:   Click multiple times to create multiple connected lines, then press `Return` or `Esc` to confirm.

Annotate Eraser
:   Click and drag to remove lines.
    The eraser has a *Radius* setting found in Tool Settings.
user: Give a detailed overview of Set Handle Type Node: syntax, arguments, return values, common patterns.

assistant: # Set Handle Type Node

[image reference removed]

Sets the handle type for the points on the Bézier curve that are in the selection.

A selection for a certain handle type can be retrieved with
the [Handle Type Selection Node](../read/handle_type_selection.xhtml).
user: How do I use Group Output in Blender? Include parameters, examples, warnings and best practices.

assistant: # Group Output

[image reference removed]

The *Group Output* node defines the final output of a node group.
It determines which values are passed out of the node group to the parent node tree
(or to the renderer, in the case of the Compositor).

In the Compositor, this node defines the image result that is sent to the renderer or to
image output after rendering.

This node is updated automatically after each evaluation or render,
and updates interactively when connected inputs are changed—provided that all inputs are fully evaluated.
user: Explain Inputs in complete detail according to the official Blender documentation.

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

Surface Input Type
:   Defines how the surface geometry is provided for attachment.
    The geometry input takes priority if both are connected.

    Object:
    :   Use an object reference as the target surface.

    Geometry:
    :   Use a geometry input directly connected to the surface mesh.

Surface
:   The surface object or geometry used as the attachment target.
    Its transforms must match the modifier object for proper alignment.

Surface UV Map
:   The UV map used to determine the attachment points on the surface mesh.
    These coordinates are stored per curve to maintain attachment consistency.

Surface Rest Position
:   When enabled, sets the surface mesh into its rest position before attachment.
    This ensures consistency when later deforming curves along the same surface.

Sample Attachment UV
:   Samples the *Surface UV Map* at the attachment point and stores the UV coordinates
    for each curve.
    This allows later nodes to access or reuse the attachment data.

Snap to Surface
:   Projects the root of each curve onto the closest point of the surface mesh,
    ensuring that all roots lie directly on the surface.

Align to Surface Normal
:   Rotates each curve so that its root direction aligns with the surface normal.
    This typically requires guide data or consistent curve orientation to produce
    stable results.

Blend along Curve
:   Blends the deformation or alignment effect gradually along each curve,
    from root to tip, instead of applying it uniformly.
user: How do I use Bpy.Types.Greasepencildrawing in Blender? Include parameters, examples, warnings and best practices.

assistant: uct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ GreasePencilFrame.drawing Next GreasePencilEnvelopeModifier(Modifier) Previous GreasePencilDashModifierSegment(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page GreasePencilDrawing(bpy_struct) GreasePencilDrawing GreasePencilDrawing.attributes GreasePencilDrawing.color_attributes GreasePencilDrawing.curve_offsets GreasePencilDrawing.type GreasePencilDrawing.user_count GreasePencilDrawing.strokes GreasePencilDrawing.add_strokes() GreasePencilDrawing.remove_strokes() GreasePencilDrawing.resize_strokes() GreasePencilDrawing.reorder_strokes() GreasePencilDrawing.set_types() GreasePencilDrawing.tag_positions_changed() GreasePencilDrawing.vertex_group_assign() GreasePencilDrawing.vertex_group_remove() GreasePencilDrawing.set_vertex_weights() GreasePencilDrawing.bl_rna_get_subclass() GreasePencilDrawing.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Give a detailed overview of Drivers: syntax, arguments, return values, common patterns.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Windows, drivers are provided by the graphics card manufacturer (AMD). Windows Update automatically installs
graphics drivers, or your computer manufacturer may provide its own version of the graphics drivers.

However, these are not always the latest version or may have been corrupted in some way. We recommend always using
the official drivers.

[Download Latest AMD Drivers](https://www.amd.com/en/support)
user: What is Performance and how is it used in Blender Python scripting?

assistant: Sampling for light linking is most efficient with the [light tree](../cycles/render_settings/sampling.xhtml#bpy-types-cyclesrendersettings-use-light-tree) enabled, where a specialized acceleration structure is built for
light linking.

When using shadow linking, renders can be slower and trace additional rays,
as direct and indirect lighting take different paths.
user: What is SDF Grid Offset Node and how is it used in Blender Python scripting?

assistant: # SDF Grid Offset Node

[image reference removed]

The *SDF Grid Offset* node offsets the surface of a Signed Distance Field (SDF)
by a specified world-space distance.
This operation effectively dilates (expands) or erodes (contracts) the
surface while maintaining the correct signed distance values across the field.

A positive offset increases the surface thickness by pushing it outward,
while a negative offset shrinks it inward. This is a fundamental operation in
volumetric modeling, useful for adjusting wall thickness, creating shells,
expanding collision volumes, or controlling blend margins between shapes.
user: Show practical ways to work with Attribute Data Types in a Blender add-on or script – include code.

assistant: The type of an attribute is the kind of data stored at each element.

Float:
:   Single floating-point value, commonly used for weights or intensity values.

Boolean:
:   True or false value for binary conditions.

Integer:
:   32-bit integer, used for indices or discrete values.

Vector:
:   3D vector with floating-point values, often representing directions or positions.

Color:
:   RGBA color with 32-bit floating-point values, stored in linear [Color Space](../../glossary/index.xhtml#term-Color-Space)
    Suitable for high dynamic range and wide-gamut colors.

Byte Color:
:   RGBA color with 8-bit positive integer values, useful for compact color storage.
    These are always stored in the sRGB [Color Space](../../glossary/index.xhtml#term-Color-Space).
    For wide gamut or linear workflows, use the *Color* type instead.

String:
:   Text string for storing names or labels.

2D Vector:
:   2D vector with floating-point values, often used for UV coordinates.

8-Bit Integer:
:   Small integer with a range from -128 to 127.

2D 16-Bit Integer Vector:
:   Signed 16-bit 2D vector for compact storage of integer pairs.

2D Integer Vector:
:   Signed 32-bit 2D vector.

Quaternion:
:   Floating-point [Quaternion](../../glossary/index.xhtml#term-Quaternion) rotation used in 3D transformations.

4x4 Matrix:
:   Floating-point matrix used for transformations or storing spatial relationships.

The above list is in the order of least to most “complex” (An integer can contain more data than a
boolean, so it is more complicated). When joining separate geometries together, the more complex data
type is preferred when there are matching names. This is particularly important when joining geometry
with named attributes with the [Join Geometry Node](geometry/join_geometry.xhtml).

To store 2D Vectors (UV maps) and Byte Colors the
[Store Named Attribute Node](attribute/store_named_attribute.xhtml) must be
used because there are no sockets for those types.

### Data Conversion

Through the use of Geometry Nodes, data can be converted between types.

Valid conversions:

- Between color and vector – mapping between color channels and vector components.
- Between color and float – the color data is converted to its grayscale equivalent.
- Between float and integer – integers simply become floats, floats are truncated.
- Between float and vector – when a float becomes a vector the value is used for each component.
  When a vector becomes a float the average of the components is taken.
- Between float and boolean – values greater than 0 are true, true maps to 1, and false maps to 0.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Many nodes have settings which can affect the way they interact with inputs and outputs.
Node settings are located below the outputs and above any inputs.

[image reference removed]

An example of the controls on the Chroma Key node.
user: Give a detailed overview of Using Custom Cameras: syntax, arguments, return values, common patterns.

assistant: In order to use a custom camera, set the [lens type](../../cameras.html#camera-lens-type) to Custom.

This enables the selection of a text data-block or external file, similar to the
[Script node](../../shader_nodes/utilities/script.html#bpy-types-shadernodescript) in shaders.

If the selected camera shader has parameters, they will be displayed below the Lens panel.
user: Describe Checkboxes & Toggle Buttons from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Checkboxes and Toggle buttons.

These controls are used to activate or deactivate options.
Use `LMB` to change their state. A tick is shown on checkboxes when
the option is activated. Active status on toggle buttons is indicated
either by color on the icon background, or a change in icon graphics.

Use `Ctrl`-`Wheel` to cycle through on/off states.

### Dragging

To change many values at once on or off, you can press down
`LMB` and drag over multiple buttons.
user: How do I use Select Linked in Blender? Include parameters, examples, warnings and best practices.

assistant: Selects all the bones in the chain which the active (last selected) bone belongs to.

All Forks
:   Selects all bones connected to the active bone even if the branch off from the current bone.

Linked bones selection.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_single-bone.png   A single selected bone. | ../../../_images/animation_armatures_bones_selecting_whole-chain.png   Its whole chain selected with Linked. |
user: Describe Vertex Paint Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Selection Mask
:   Vertex Paint Mode in Grease Pencil allows you to select points or strokes to restrict the effect
    of the painting tools to only a certain areas of your drawing.

    You can use the selection tools in the Toolbar for a quick selections.

    You can restrict painting only on the selected points or strokes with the Selection mode toggle.
    The three modes can be toggled with `1`, `2`, or `3` respectively.

Multiframe
:   Sometimes you may need to modify several frames at the same time with the painting tools.

    You can activate multiframe editing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../../multiframe.xhtml) for more information.
user: What is XrActionMapItems(bpy_struct) and how is it used in Blender Python scripting?

assistant: # XrActionMapItems(bpy_struct)

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

*class* bpy.types.XrActionMapItems(*bpy_struct*)
:   Collection of XR action map items

    new(*name*, *replace_existing*)
    :   new

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name of the action map item
            - **replace_existing** (*boolean*) – Replace Existing, Replace any existing item with the same name

        Returns:
        :   Item, Added action map item

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

    new_from_item(*item*)
    :   new_from_item

        Parameters:
        :   **item** ([`XrActionMapItem`](bpy.types.XrActionMapItem.html#bpy.types.XrActionMapItem "bpy.types.XrActionMapItem"), (never None)) – Item, Item to use as a reference

        Returns:
        :   Item, Added action map item

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

    remove(*item*)
    :   remove

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

    find(*name*)
    :   find

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, The action map item with the given name

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

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

assistant: # Blend

The Blend texture generates a smoothly interpolated progression.
This is one of the most frequently used procedural textures.
You can use blend textures to blend other textures together (with *Stencil*),
or to create nice effects (especially with the *Mapping: Normal* trick).

[image reference removed]

Blend Texture panels.
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Solver
:   Algorithm used to calculate the Boolean intersections.

    Exact:
    :   Uses a complex solver which offers the best results and has full
        support for overlapping geometry; however, this solver is much slower.

    Float:
    :   Uses a simple solver which offers the good performance;
        however, this solver lacks support for overlapping geometry.

    Manifold:
    :   Uses a solver that is usually fastest but only works on [Manifold](../../../glossary/index.html#term-Manifold) meshes,
        (plus the special case of Difference with a plane).

Trim Mode
:   Geometry can be either added or removed by choosing one of these modes.

    Difference:
    :   Removes geometry, filling any holes that are created.

    Union:
    :   Creates a geometry and joins any intersections with existing geometry.

    Join:
    :   Similar to *Union* but joins the mesh as separate geometry,
        without performing any Boolean operations with existing geometry.

Shape Orientation
:   The method used to orientate the trimming shape.

    View:
    :   Use the view to orientate the trimming shape.

    Surface:
    :   Use the surface normal to orientate the trimming shape.

Extrude Mode
:   Fixed:
    :   Aligns new geometry orthogonally for 90 degree angles in depth.

    Project:
    :   Aligns new geometry with the perspective of the current view for a tapered result.

Use Cursor for Depth
:   Use cursor location and radius for the dimensions and position of the trimming shape.
    If not set, the tool uses the full depth of the object from the camera view.
user: Describe Inverse Kinematics from the Blender manual or Python API, including usage steps and snippets.

assistant: # Inverse Kinematics

[image reference removed]

The Inverse Kinematics panel.

This panel controls the way a bone or set of bones behave when linked in
an [inverse kinematic](../../posing/bone_constraints/inverse_kinematics/introduction.html) chain.
user: What is Usage and how is it used in Blender Python scripting?

assistant: ### Selecting a Brush and Material

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

### Free-hand Drawing

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

Drawing free-hand strokes.

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

### Stabilize Stroke

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

Drawing strokes using *Stabilize Stroke*.

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

### Straight Lines

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

### Switching to the Erase Tool

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

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

assistant: A shader is a program that runs on the GPU (written in GLSL in our case).
There are multiple types of shaders.
The most important ones are *Vertex Shaders* and *Fragment Shaders*.
Typically multiple shaders are linked together into a *Program*.
However, in the Blender Python API the term *Shader* refers to an OpenGL Program.
Every `gpu.types.GPUShader` consists of a vertex shader, a fragment shader and an optional geometry shader.
For common drawing tasks there are some built-in shaders accessible from [`gpu.shader.from_builtin`](gpu.shader.html#gpu.shader.from_builtin "gpu.shader.from_builtin")
with an identifier such as `UNIFORM_COLOR` or `FLAT_COLOR`. There are specific builtin shaders for
drawing triangles, lines and points.

Every shader defines a set of attributes and uniforms that have to be set in order to use the shader.
Attributes are properties that are set using a vertex buffer and can be different for individual vertices.
Uniforms are properties that are constant per draw call.
They can be set using the `shader.uniform_*` functions after the shader has been bound.
user: How do I use Open Shading Language in Blender? Include parameters, examples, warnings and best practices.

assistant: # Open Shading Language

[Open Shading Language (OSL)](https://github.com/AcademySoftwareFoundation/OpenShadingLanguage)
is a programmable shading system developed for advanced rendering engines.
It allows technical artists and developers to write custom shader code using a C-like scripting language.

In Blender, OSL can be used within Cycles to define custom surface, volume, and displacement shaders.
This gives users full control over shading behavior, enabling procedural effects, advanced lighting models,
and custom geometry-based material logic that may not be possible with built-in shader nodes alone.

Unlike node-based materials, OSL shaders are authored as text scripts using Blender’s internal
[Text Editor](../../../editors/text_editor.html) or loaded from external .osl or .oso files.
These scripts are then compiled and used in the Shader Editor
through the [Script Node](../../shader_nodes/utilities/script.html).
user: Show practical ways to work with Bokeh Blur Node in a Blender add-on or script – include code.

assistant: # Bokeh Blur Node

[image reference removed]

The Bokeh Blur node generates a bokeh type blur similar to Defocus.
Unlike defocus an in-focus region is defined in the Compositor.
There is also more flexibility in the type of blur applied through
the [Bokeh Image](../../input/bokeh_image.xhtml) node.

Several performance optimizations are also available such calculation area restriction and masking.
user: How do I use Proportional Editing in Blender? Include parameters, examples, warnings and best practices.

assistant: # Proportional Editing

[image reference removed]

Proportional Editing popover.

Proportional Editing is a way of transforming selected elements while also affecting
the nearby unselected elements. The farther away an unselected element is, the less it will be affected
(hence the “proportional”). This feature is very useful for smoothly deforming dense meshes.