PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: Extrude Point
:   `LMB` click to add a new point connected to the currently selected point.
    The new point will have [handle type](../../curves/structure.xhtml#curve-bezier-handle-type) of *Vector*.
    `Shift`-`LMB` click will add point as type *Auto*.
    However, the handle type switches to *Align* when handles are moved (See *Move Point*).

Delete Point
:   `Ctrl`-`LMB` click on an existing point to delete it.

Insert Point
:   `Ctrl`-`LMB` click on a [Curve Segment](../../../glossary/index.xhtml#term-Curve-Segment) to insert a new control point between the two
    adjacent control points. `Ctrl`-`LMB` click and drag to control the handles of the inserted points.

Move Segment
:   `LMB` drag on a segment in between two control points to adjust the handles, changing the shape of the
    curve without affecting the location of any control points.

Select Point
:   `LMB` click to select a single point or handle at a time.

Move Point
:   `LMB` drag to move existing points or handles. With an endpoint of a stroke selected,
    click and drag on empty space to *Extrude Point* and move the handle at the same time.

Close Stroke
:   Make the stroke [Cyclic](../../../glossary/index.xhtml#term-Cyclic) by clicking the endpoints.

Cycle Handle Type
:   Double `LMB` click on the control point to cycle through all handle types.
user: Explain GeometryNodeRemoveAttribute(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeRemoveAttribute(GeometryNode)

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

*class* bpy.types.GeometryNodeRemoveAttribute(*GeometryNode*)
:   Delete an attribute with a specified name from a geometry. Typically used to optimize performance

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

assistant: ### Types

- [2D Offset](modifiers/geometry/2d_offset.xhtml)
- [2D Transform](modifiers/geometry/2d_transform.xhtml)
- [Backbone Stretcher](modifiers/geometry/backbone_stretcher.xhtml)
- [Bézier Curve](modifiers/geometry/bezier_curve.xhtml)
- [Blueprint](modifiers/geometry/blueprint.xhtml)
- [Guiding Lines](modifiers/geometry/guiding_lines.xhtml)
- [Perlin Noise 1D](modifiers/geometry/perlin_noise_1d.xhtml)
- [Perlin Noise 2D](modifiers/geometry/perlin_noise_2d.xhtml)
- [Polygonization](modifiers/geometry/polygonization.xhtml)
- [Sampling](modifiers/geometry/sampling.xhtml)
- [Simplification](modifiers/geometry/simplification.xhtml)
- [Sinus Displacement](modifiers/geometry/sinus_displacement.xhtml)
- [Spatial Noise](modifiers/geometry/spatial_noise.xhtml)
- [Tip Remover](modifiers/geometry/tip_remover.xhtml)
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Surface
:   Shading for the [surface](../../materials/components/surface.html) of the object.

Volume
:   Shading for the [volume](../../materials/components/volume.html) inside the object.

Displacement
:   Used to create bump mapping or actual subdivided [displacement](../../materials/components/displacement.html).

Thickness EEVEE
:   Used to approximate the inner geometry structure of the object without heavy computation.
    This is currently used for [Subsurface Scattering](../shader/sss.html),
    [Translucent BSDF](../shader/translucent.html),
    [Refraction BSDF](../shader/refraction.html), and the nodes containing these effects.

    If no value is plugged into the output node,
    a default thickness based on the smallest dimension of the object is used.
    If a value is connected it will be used as object space thickness (i.e. scaled by object transform).
    A value of zero will disable the thickness approximation and treat the object as having only one interface.

    This output is only used by the EEVEE render engine.
user: Provide the full official documentation entry for Thickness, preserving all code examples.

assistant: Printers have a limited *wall-thickness* where very thin areas cannot be printed,
this test uses ray casting and a distance range to the thickness of the geometry.

Minimum/Maximum
:   Minimum/Maximum thickness to display.

Samples
:   Number of samples to use to calculate the thickness.

[image reference removed]

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

assistant: [image reference removed]

The Mesh to Volume modifier.

Object
:   The mesh object that determines where the volume data will be generated.

Density
:   Makes the generated volume appear denser or less dense when rendering.

Interior Band Width
:   The maximum distance of the included voxels to the surface on the inside of the mesh.

Resolution Mode
:   Mode for how the voxel size is specified.

    Voxel Amount:
    :   This allows setting an approximate number of voxels that will be used to represent mesh along its diagonal.
        When the dimensions of the mesh changes, the voxel size will change as well.
        For final rendering of animations, it’s better to specify the voxel size explicitly to avoid artifacts.

    Voxel Size:
    :   This allows setting the exact voxel size that will be used.
        This is idea for rendering when the voxel size should not change between frames.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: After the modal tool is run
the [Loop Cut and Slide Options](../editing/edge/loopcut_slide.html#modeling-meshes-editing-edge-loopcut-slide-options)
are available in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.
user: How do I use F-Curve Modifiers in Blender? Include parameters, examples, warnings and best practices.

assistant: # F-Curve Modifiers

F-Curve modifiers are similar to object modifiers, in that they add non-destructive effects
that can be adjusted at any time and layered to create more complex effects.

Modifiers are evaluated from top to bottom.
You can change their order by dragging the dots in their top right corner.
user: Provide the full official documentation entry for The operator still doesn’t work!, preserving all code examples.

assistant: Certain operators in Blender are only intended for use in a specific context,
some operators for example are only called from the properties editor where they check the current material,
modifier or constraint.

Examples of this are:

- [`bpy.ops.texture.slot_move`](bpy.ops.texture.html#bpy.ops.texture.slot_move "bpy.ops.texture.slot_move")
- [`bpy.ops.constraint.limitdistance_reset`](bpy.ops.constraint.html#bpy.ops.constraint.limitdistance_reset "bpy.ops.constraint.limitdistance_reset")
- [`bpy.ops.object.modifier_copy`](bpy.ops.object.html#bpy.ops.object.modifier_copy "bpy.ops.object.modifier_copy")
- [`bpy.ops.buttons.file_browse`](bpy.ops.buttons.html#bpy.ops.buttons.file_browse "bpy.ops.buttons.file_browse")

Another possibility is that you are the first person to attempt to use this operator
in a script and some modifications need to be made to the operator to run in a different context.
If the operator should logically be able to run but fails when accessed from a script
it should be reported to the bug tracker.
user: Explain Curves Menu in complete detail according to the official Blender documentation.

assistant: Snap to Deformed Surface
:   Re-attach curves to a deformed surface using the existing attachment information.
    This only works when the topology of the surface mesh has not changed.

Snap to Nearest Surface
:   Find the closest point on the surface for the root point of every curve and move the root there.
    This needs to be run after the surface mesh topology changed

Convert to Particle System
:   Add a new hair particle system, or update an system on the surface object.
    The operator is used for backwards compatibility with the old
    [hair type particle system](../../physics/particles/hair/introduction.xhtml).
user: Give a detailed overview of CompositorNodeEllipseMask(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeEllipseMask(CompositorNode)

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

*class* bpy.types.CompositorNodeEllipseMask(*CompositorNode*)
:   Create elliptical mask suitable for use as a simple matte or vignette mask

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Import PLY Node

[image reference removed]

The *Import PLY* node imports mesh data from a .ply (Polygon File Format or Stanford Triangle Format) file.

PLY files typically store geometry from 3D scanning or modeling software and can include
vertex attributes such as colors or normals. The geometry is imported as a single mesh.

This node allows procedural workflows to incorporate external static geometry directly into Geometry Nodes.
user: Describe Frame Range from the Blender manual or Python API, including usage steps and snippets.

assistant: # Frame Range

[image reference removed]

Frame Range panel.

This panel defines how long an animation will last in terms of frames.
Frames can be divided by the scene’s [Frame Rate](format.xhtml#bpy-types-rendersettings-fps)
to get the animation duration in terms of time.
For example, a 250 frame animation at a frame rate of 30 will last 8.3 seconds.

Frame Start, End
:   Set the *Start* and *End* frames for [Rendering Animations](../animation.xhtml).

Step
:   Controls the number of frames to advance for each frame rendered, a value above 1 skips frames.
    This is also used when viewing rendered animations.
user: Show practical ways to work with bpy_extras submodule (bpy_extras.node_utils) in a Blender add-on or script – include code.

assistant: # bpy_extras submodule (bpy_extras.node_utils)

bpy_extras.node_utils.connect_sockets(*input*, *output*)
:   Connect sockets in a node tree.

    This is useful because the links created through the normal Python API are
    invalid when one of the sockets is a virtual socket (grayed out sockets in
    Group Input and Group Output nodes).

    It replaces node_tree.links.new(input, output)

bpy_extras.node_utils.find_base_socket_type(*socket*)
:   Find the base class of the socket.

    Sockets can have a subtype such as NodeSocketFloatFactor,
    but only the base type is allowed, e. g. NodeSocketFloat

bpy_extras.node_utils.find_node_input(*node*, *name*)
user: Explain Preview Snapping in complete detail according to the official Blender documentation.

assistant: # Preview Snapping

The icon toggles snapping;
you can also do this temporarily by holding `Ctrl` after starting to transform an image.

Images have multiple snap points; they can snap along their edges, corners, or center.

The drop-down arrow offers the following options:

Snap to
:   Borders
    :   Snap images to the edges of the render region.

    Center
    :   Snap images to the horizontal and vertical center lines of the render region.

    Other Strips
    :   Snap images to the snap points of other images.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Mesh
:   Standard mesh input.

Start Vertices
:   A selection of the vertices to start at when traveling along the next vertex indices.

Next Vertex Index
:   Describes the path to follow at every vertex.
user: How do I use Drag & Dropping to 3D Viewport in Blender? Include parameters, examples, warnings and best practices.

assistant: Dragging an object from the Outliner to the [3D Viewport](../3dview/index.xhtml)
creates a [duplicate](../../scene_layout/object/editing/duplicate.xhtml) – a new object with its own copy
of the underlying object data.

Dragging object data from the Outliner to the 3D Viewport creates a
[linked duplicate](../../scene_layout/object/editing/duplicate_linked.xhtml) – a new object that references
the same underlying object data.
user: Give a detailed overview of LineStyleThicknessModifier_Tangent(LineStyleThicknessModifier): syntax, arguments, return values, common patterns.

assistant: # LineStyleThicknessModifier_Tangent(LineStyleThicknessModifier)

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

*class* bpy.types.LineStyleThicknessModifier_Tangent(*LineStyleThicknessModifier*)
:   Thickness based on the direction of the stroke

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    thickness_max
    :   Maximum thickness

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

    thickness_min
    :   Minimum thickness

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Thickness Modifier Type Items](bpy_types_enum_items/linestyle_thickness_modifier_type_items.html#rna-enum-linestyle-thickness-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleThicknessModifier_Tangent.type "bpy.types.LineStyleThicknessModifier_Tangent.type")
user: Describe Armature Mode Switching from the Blender manual or Python API, including usage steps and snippets.

assistant: While writing scripts that deal with armatures you may find you have to switch between modes,
when doing so take care when switching out of Edit-Mode not to keep references
to the edit bones or their head/tail vectors.
Further access to these will crash Blender so it’s important that the script
clearly separates sections of the code which operate in different modes.

This is mainly an issue with Edit-Mode since pose data can be manipulated without having to be in Pose-Mode,
yet for operator access you may still need to enter Pose-Mode.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

In addition to modeling and animation, Blender can be used to edit videos.
There are two possible methods for this, one being the [Compositor](../compositing/introduction.xhtml)
and the other, described in this chapter, being the Video Sequencer.
The Video Sequencer within Blender is a complete video editing system that allows you to combine multiple
video channels and add effects to them. You can use these effects to create powerful video edits,
especially when you combine it with the animation power of Blender!

To use the Video Sequencer, you load multiple video clips and lay them end-to-end (or in some cases, overlay them),
inserting fades and transitions to link the end of one clip to the beginning of another.
Finally, you can add audio and synchronize the timing of the video sequence to match it.

[image reference removed]

Default Video Editing screen layout.
user: How do I use Group Input in Blender? Include parameters, examples, warnings and best practices.

assistant: Exposes the inputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
bringing in each input right where you need it (rather than dragging long links all across your graph).

The input slots can be edited in the *Group* tab of the *Sidebar*.
user: Explain LineStyleGeometryModifier_GuidingLines(LineStyleGeometryModifier) in complete detail according to the official Blender documentation.

assistant: # LineStyleGeometryModifier_GuidingLines(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_GuidingLines(*LineStyleGeometryModifier*)
:   Modify the stroke geometry so that it corresponds to its main direction line

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    offset
    :   Displacement that is applied to the main direction line along its normal

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

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_GuidingLines.type "bpy.types.LineStyleGeometryModifier_GuidingLines.type")
user: Provide the full official documentation entry for Geometry, preserving all code examples.

assistant: Offset
:   Offset the control points of the curves defining the letters, which will make them thinner or thicker.
    Use with care, it can quickly lead to artifacts…

### Extrusion, Taper & Bevel

The remaining settings of that panel, which are used to give volume to the letters,
are also shared with the [Curves](../curves/properties/geometry.xhtml) data-blocks,
please refer to those for details.
user: What is EQCurveMappingData(bpy_struct) and how is it used in Blender Python scripting?

assistant: # EQCurveMappingData(bpy_struct)

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

*class* bpy.types.EQCurveMappingData(*bpy_struct*)
:   EQCurveMappingData

    curve_mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (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: Describe Linestyle Thickness Modifier Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Linestyle Thickness Modifier Type Items

ALONG_STROKE:
:   Along Stroke.

CALLIGRAPHY:
:   Calligraphy.

CREASE_ANGLE:
:   Crease Angle.

CURVATURE_3D:
:   Curvature 3D.

DISTANCE_FROM_CAMERA:
:   Distance from Camera.

DISTANCE_FROM_OBJECT:
:   Distance from Object.

MATERIAL:
:   Material.

NOISE:
:   Noise.

TANGENT:
:   Tangent.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`Object.animation_visualization`](bpy.types.Object.html#bpy.types.Object.animation_visualization "bpy.types.Object.animation_visualization") | - [`Pose.animation_visualization`](bpy.types.Pose.html#bpy.types.Pose.animation_visualization "bpy.types.Pose.animation_visualization") |
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Is Hit
:   Boolean output that is true for each ray which has hit the *Target Geometry*.

Hit Position
:   The location of the intersection point with the target mesh.

Hit Normal
:   The surface [Normal](../../../../glossary/index.xhtml#term-Normal) vector at the hit location.

Hit Distance
:   The distance from the *Source Position* to the *Hit Position*.
    If the ray does not hit, the *Ray Length* is returned.

Attribute
:   Interpolated values of the *Attribute* input sampled at the *Hit Position*.
user: Describe Select Face Loops from the Blender manual or Python API, including usage steps and snippets.

assistant: In face select mode, holding `Alt` while selecting an *edge* selects a loop of
faces that are connected in a line end-to-end, along their opposite edges.

In vertex select mode,
the same can be accomplished by using `Ctrl`-`Alt` to select an edge,
which selects the face loop implicitly.

[image reference removed]

Face loop selection.

This face loop was selected by clicking with `Alt`-`LMB` on an edge,
in *face* select mode.
The loop extends perpendicular from the edge that was selected.

[image reference removed]

`Alt` versus `Ctrl`-`Alt` in vertex select mode.

A face loop can also be selected in *Vertex* select mode.
Technically `Ctrl`-`Alt`-`LMB` will select an *Edge Ring*,
however, in *Vertex* select mode, selecting an *Edge Ring* implicitly
selects a *Face Loop* since selecting opposite edges of a face implicitly selects
the entire face.
user: What is Mask From Cavity and how is it used in Blender Python scripting?

assistant: Generates a mask based on the cavity of the surface. The settings of the operation can be changed
in the [Adjust Last Operation](../../../interface/undo_redo.xhtml) panel.

Mode
:   Choose how the newly created mask is mixed with the existing one. By default it will replace the old mask via
    “Mix”.

Mix Factor
:   The factor of the mix effect. Choose how strong the new mask is applied on the existing one.

Automask Settings
:   The same settings as the [Auto-Masking](../controls.xhtml) settings are applied.

Factor
:   Same as [Auto-Masking](../controls.xhtml).

Blur
:   Same as [Auto-Masking](../controls.xhtml).

Invert
:   Same as [Auto-Masking](../controls.xhtml).

Custom Curve
:   Same as [Auto-Masking](../controls.xhtml).
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Image.packed_file`](bpy.types.Image.html#bpy.types.Image.packed_file "bpy.types.Image.packed_file") - [`ImagePackedFile.packed_file`](bpy.types.ImagePackedFile.html#bpy.types.ImagePackedFile.packed_file "bpy.types.ImagePackedFile.packed_file") - [`Library.packed_file`](bpy.types.Library.html#bpy.types.Library.packed_file "bpy.types.Library.packed_file") | - [`Sound.packed_file`](bpy.types.Sound.html#bpy.types.Sound.packed_file "bpy.types.Sound.packed_file") - [`VectorFont.packed_file`](bpy.types.VectorFont.html#bpy.types.VectorFont.packed_file "bpy.types.VectorFont.packed_file") - [`Volume.packed_file`](bpy.types.Volume.html#bpy.types.Volume.packed_file "bpy.types.Volume.packed_file") |
user: Give a detailed overview of Linear Workflow: syntax, arguments, return values, common patterns.

assistant: Different [Color Spaces](../../glossary/index.html#term-Color-Space)
are needed for rendering, display and storage of images.

Rendering and compositing is best done in a *scene linear* color space,
which corresponds more closely to nature, and makes computations more physically accurate.
Blender primarily works with scene linear colors for materials, lighting, geometry and
compositing.

However, these values do not directly correspond to human perception or the way display devices
work. Image files are also often stored in different color spaces for more efficient compression.

For a correct linear workflow, it is important to assign the correct color spaces for images
and displays. Blender will then perform conversion to and from scene linear colors.

[[image reference removed]](../../_images/render_color-management_linear-workflow.svg)

An example of a linear workflow.
user: How do I use Target Selection in Blender? Include parameters, examples, warnings and best practices.

assistant: Sets more detailed snapping options. The available options depend on the mode
(Object/Edit) as well as the [Snap Target](#bpy-types-toolsettings-snap-elements-base).

Include Active Edit Mode
:   Snap to other mesh elements of the active object.

    This checkbox is ignored if
    [Proportional Editing](proportional_editing.xhtml)
    is enabled.

Include Edited Edit Mode
:   Snap to other objects that are also in Edit Mode.

Include Non-Edited Edit Mode
:   Snap to other objects that are not in Edit Mode.

Exclude Non-Selectable
:   Snap only to objects that are selectable.

Align Rotation to Target
:   Rotates the selection so that its Z axis gets aligned to the normal of the target.

Backface Culling
:   Exclude back-facing geometry from snapping.

Snap to Same Target Face Nearest
:   Snap only to the object which the selection was nearest to before starting
    the transformation.

Face Nearest Steps Face Nearest Edit Mode
:   Breaks the overall transformation into multiple steps, performing a snap each time.
    This can give better results in certain cases.

Snap Peel Object Volume
:   If the target object is composed of several disconnected mesh islands that
    intersect each other, “Snap To Volume” will normally snap to the island which the
    mouse is hovering over, ignoring the other islands. By enabling “Snap Peel Object,”
    you can instead treat the target object as one connected whole.
user: Show practical ways to work with Object Mode in a Blender add-on or script – include code.

assistant: Proportional Editing is typically used in *Edit Mode*, but it can also be used in *Object Mode*.
The tool then works on entire objects rather than individual mesh components.

In the image below, the leftmost cylinder is being scaled up vertically,
which also affects the cylinders near it.

[[image reference removed]](../../../_images/editors_3dview_controls_proportional-editing_object-mode.png)

Proportional Editing in Object Mode.
user: What is Conventions Used in This Manual and how is it used in Blender Python scripting?

assistant: ### Keyboard

Hotkeys are shown in this manual as they appear on a keyboard. For example:

|  |  |
| --- | --- |
| `G` | The “G” key by itself (as though you were typing a lowercase “g”). |
| `Shift`, `Ctrl`, `Alt` | Modifier keys. |
| `Ctrl`-`W`, `Shift`-`Alt`-`A` | Keys pressed simultaneously. |
| `0` to `9` | The number keys on the row above the letters. |
| `Numpad0` to `Numpad9`, `NumpadPlus` | The keys on the separate numeric keypad. |

Other keys are referred to by name, such as `Esc`, `Tab`,
and `F1` through `F12`.
Arrow keys are written as `Left`, `Right`, and so on.

### Mouse

Mouse buttons and wheel actions are referred to as:

|  |  |
| --- | --- |
| `LMB` | Left Mouse Button |
| `RMB` | Right Mouse Button |
| `MMB` | Middle Mouse Button |
| `Wheel`, `WheelUp`, `WheelDown` | Scrolling the mouse wheel. |
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Value
:   The Gabor noise value with both random intensity and phase. This is equal to sine the phase
    multiplied by the intensity.

Phase
:   The phase of the Gabor noise, which has no random intensity.

Intensity
:   The intensity of the Gabor noise, which has no random phase.
user: How do I use Randomize in Blender? Include parameters, examples, warnings and best practices.

assistant: Randomize the scale, rotation and offset of selected UV islands.
The *Randomize Transform* tool in the UV editor works
similar to *Randomize Transform* tool in the 3d view.

Random Seed
:   Changes the random [seed](../../../glossary/index.html#term-Seed) used by the pseudo-random number generator,
    producing a different transform result for each seed value.

Location
:   Amount to randomize location.

Rotation
:   Amount to randomize rotation.

Scale Even
:   Apply the same scale to the U coordinate and V coordinate.

Scale
:   Amount to randomize scale in U and V coordinates.
user: What is Unsupported Graphics Driver Error and how is it used in Blender Python scripting?

assistant: This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.
user: Give a detailed overview of Animated Transform to Deltas: syntax, arguments, return values, common patterns.

assistant: Converts existing animation keyframes from the object’s primary transforms
(*Location*, *Rotation*, *Scale*) into [Delta Transforms](../properties/transforms.html#bpy-types-object-delta).

This means that the animation data is moved from the main transform channels
to the corresponding delta channels, leaving the main transforms unchanged at their current values.
user: Describe GeometryNodeSeparateGeometry(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeSeparateGeometry(GeometryNode)

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

*class* bpy.types.GeometryNodeSeparateGeometry(*GeometryNode*)
:   Split a geometry into two geometry outputs based on a selection

    domain
    :   Which domain to separate on

        Type:
        :   enum in [Attribute Domain Without Corner Items](bpy_types_enum_items/attribute_domain_without_corner_items.html#rna-enum-attribute-domain-without-corner-items), default `'POINT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Transform operations use the [snapping settings](../../editors/3dview/controls/snapping.xhtml) set in the scene.
However, some options can be changed during the transformation.

### Snap Invert

Even if the magnetic icon is disabled, you can still enable snapping during a transformation.
The default hotkey in this case is `Ctrl`.

### Set Snap Base

The Snap Base is automatically determined based on the [Snap Base](../../editors/3dview/controls/snapping.xhtml#bpy-types-toolsettings-snap-target) options.
However, this automatic snap detection point of origin may not always align with the user’s intentions.
Therefore, transform operations include a utility to set a new snap origin point during the transformation.
The new Snap Base will correspond to the snap point whose target is defined by the
[Snap Target](../../editors/3dview/controls/snapping.xhtml#bpy-types-toolsettings-snap-elements-base).

By default the hotkey is `B`.

### Add Snap Point

While you’re transforming a selection with snapping enabled,
you can press `A` whenever there’s a highlighted snap target to
mark it. With multiple such targets marked, the selection will
then be snapped to their average location.

Marking a target more than once will give it more weight.

[image reference removed]

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

assistant: Mesh
:   Standard geometry input.

Level
:   The number of subdivisions to apply to the input geometry.

Edge Crease
:   Controls how smooth edges should be with [Weighted Edge Creases](../../../modifiers/generate/subdivision_surface.xhtml#modifiers-generate-subsurf-creases).

Vertex Crease
:   Controls how much the subdivision surface should be pulled towards the vertex.
    Similar to edge creases, but allows individual vertices to be creased.

Limit Surface
:   Places vertices at the surface that would be produced with infinite
    levels of subdivision (smoothest possible shape).

UV Smooth
:   Controls how subdivision smoothing is applied to UVs.

    None:
    :   UVs remain unchanged.

    Keep Corners:
    :   UV islands are smoothed, but their boundary remain unchanged.

    Keep Corners, Junctions:
    :   UVs are smoothed, corners on discontinuous boundary and junctions of three or more regions are kept sharp.

    Keep Corners, Junctions, Concave:
    :   UVs are smoothed, corners on discontinuous boundary,
        junctions of three or more regions and darts and concave corners are kept sharp.

    Keep Boundaries:
    :   UVs are smoothed, boundaries are kept sharp.

    All:
    :   UVs and their boundaries are smoothed.

Boundary Smooth
:   Controls how open boundaries (and corners) are smoothed.

    All:
    :   Smooth boundaries, including corners.

    Keep Corners:
    :   Smooth boundaries, but corners are kept sharp.
user: Provide the full official documentation entry for Rendering, preserving all code examples.

assistant: With Cycles you can render hair with specialized hair BSDFs
[Hair BSDF](../../../render/shader_nodes/shader/hair.xhtml) or
[Principled Hair BSDF](../../../render/shader_nodes/shader/hair_principled.xhtml).

Hair can also be used as a basis for
the [Particle Instance Modifier](../../../modeling/modifiers/physics/particle_instance.xhtml),
which allows you to have a mesh be deformed along the curves,
which is useful for thicker strands, or things like grass, or feathers, which may have a more specific look.
user: Provide the full official documentation entry for Calling a File Selector, preserving all code examples.

assistant: This example shows how an operator can use the file selector.

Notice the invoke function calls a window manager method and returns
`{'RUNNING_MODAL'}`, this means the file selector stays open and the operator does not
exit immediately after invoke finishes.

The file selector runs the operator, calling [`Operator.execute`](#bpy.types.Operator.execute "bpy.types.Operator.execute") when the
user confirms.

The [`Operator.poll`](#bpy.types.Operator.poll "bpy.types.Operator.poll") function is optional, used to check if the operator
can run.

```
import bpy

class ExportSomeData(bpy.types.Operator):
    """Test exporter which just writes hello world"""
    bl_idname = "export.some_data"
    bl_label = "Export Some Data"

    filepath: bpy.props.StringProperty(subtype="FILE_PATH")

    @classmethod
    def poll(cls, context):
        return context.object is not None

    def execute(self, context):
        file = open(self.filepath, 'w')
        file.write("Hello World " + context.object.name)
        return {'FINISHED'}

    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

# Only needed if you want to add into a dynamic menu.
def menu_func(self, context):
    self.layout.operator_context = 'INVOKE_DEFAULT'
    self.layout.operator(ExportSomeData.bl_idname, text="Text Export Operator")

# Register and add to the file selector (required to also use F3 search "Text Export Operator" for quick access).
bpy.utils.register_class(ExportSomeData)
bpy.types.TOPBAR_MT_file_export.append(menu_func)

# Test call.
bpy.ops.export.some_data('INVOKE_DEFAULT')
```
user: Show practical ways to work with GeometryNodeSplitEdges(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeSplitEdges(GeometryNode)

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

*class* bpy.types.GeometryNodeSplitEdges(*GeometryNode*)
:   Duplicate mesh edges and break connections with the surrounding faces

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Set Curve Radius Node

[image reference removed]

The *Set Curve Radius* controls the radius of the curve, used for operations like the size of the profile
in the [Curve to Mesh](../operations/curve_to_mesh.xhtml) node. The value is set for
every control point, and is then interpolated to each evaluated point in between the control points.

The input node for this data is the [Radius node](../../geometry/read/radius.xhtml).
user: Provide the full official documentation entry for Flow, preserving all code examples.

assistant: # Flow

Fluid *Flow* types are used to add or remove fluid to a domain object. Flow objects should be
contained within the domain’s [Bounding Box](../../../glossary/index.xhtml#term-Bounding-Box) in order to work.

To define any mesh object as a *Flow* object, add Fluid physics by clicking *Fluid* in
Properties ‣ Physics. Then select *Flow* as the fluid *Type*. Now you should have
a default fluid flow source object.
user: Show practical ways to work with Instances to Points Node in a Blender add-on or script – include code.

assistant: # Instances to Points Node

[image reference removed]

The *Instances to Points* node generates points at the origins of top-level instances.
Attributes on the [instance domain](../attributes_reference.xhtml#attribute-domains) are moved to the point cloud points.
user: Give a detailed overview of Settings: syntax, arguments, return values, common patterns.

assistant: For the most part, *Viewport Render* uses the current viewport settings.
Some settings are located in the properties of the render engine
that is used to render the view.

Solid mode uses the render settings of Workbench;
Material Preview mode uses the render settings of EEVEE.

Additionally, some output settings are used too:

- Resolution
- Aspect
- Output path
- File format
user: What is Scenes & Layers and how is it used in Blender Python scripting?

assistant: [image reference removed]

These [data-block menus](../controls/templates/data_block.html#ui-data-block) are used to select
the current [Scene](../../scene_layout/scene/index.html) and [View Layer](../../render/layers/index.html).
user: Give a detailed overview of Delete Keyframes: syntax, arguments, return values, common patterns.

assistant: There are several methods of removing keyframes:

- In the 3D Viewport or Video Sequencer Preview press `Alt`-`I` to remove keys from selected objects, bones or strips
  on the current frame.
- When the mouse is over a value, press `Alt`-`I`.
- `RMB` a value and choose *Delete Keyframe* from the menu.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Fill Type
:   How the circle is filled with faces.

    None:
    :   Output just the edge ring without any faces.

    N-Gon:
    :   Fill the circle with a single face.

    Triangles:
    :   Fill the circle with triangles connected to a new vertex at the origin.