PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Face Marks in Blender? Include parameters, examples, warnings and best practices.

assistant: Face marks are useful for removing lines from certain areas of a mesh.

Internally, face marks are stored as the `freestyle_face`
[attribute](../../../modeling/geometry_nodes/attributes_reference.xhtml).

Marking faces is done as follows:

1. Select a mesh object and enter *Edit Mode*.
2. Select the faces you want to be marked.
3. Press `Ctrl`-`F` and select Face Data ‣ Mark Freestyle Face.

In this example, two faces of the default cube are marked like the image on the left.
On the right is a render without face marks activated.

|  |  |
| --- | --- |
| ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-1.png   Marked faces (Edit Mode). | ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-2.png   Render output. |

The line selection can be controlled via inclusion and faces options:

Negation
:   Whether to include or exclude edges matching defined face mark conditions from the line set.

Condition
:   One Face:
    :   (De)select all edges which have one or both neighbor faces marked.

    Both Faces:
    :   (De)select all edges which have both of their neighbor faces marked.

|  |  |
| --- | --- |
| ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-3.png   Inclusive, One Face. | ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-4.png   Inclusive, Both Faces. |
| ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-5.png   Exclusive, One Face. | ../../../_images/render_freestyle_parameter-editor_line-set_face-marks-example-6.png   Exclusive, Both Faces. |
user: How do I use Split Edges Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Split Edges Node

[image reference removed]

Like the [Edge Split Modifier](../../../modifiers/generate/edge_split.html), the *Split Edges* node splits and duplicates edges
within a mesh, breaking ‘links’ between faces around those split edges.
user: Describe Setup from the Blender manual or Python API, including usage steps and snippets.

assistant: Baking requires a mesh to have a UV map, and either a Color Attribute
or an Image Texture node with an image to be baked to.
The [Active](../../glossary/index.xhtml#term-Active) [Image Texture](../shader_nodes/textures/image.xhtml)
node or [Color Attribute](../../sculpt_paint/vertex_paint/index.xhtml) is used as the baking target.

Use Render Bake in intensive light/shadow solutions,
such as AO or soft shadows from area lights. If you bake AO for the main objects,
you will not have to enable it for the full render, saving render time.
Cycles uses the render settings (samples, bounces, …) for baking.
This way the quality of the baked textures should match the result you get from the rendered scene.
user: Provide the full official documentation entry for Simple Object Panel, preserving all code examples.

assistant: This panel has a [`Panel.poll`](#bpy.types.Panel.poll "bpy.types.Panel.poll") and [`Panel.draw_header`](#bpy.types.Panel.draw_header "bpy.types.Panel.draw_header") function,
even though the contents is basic this closely resembles blenders panels.

```
import bpy

class ObjectSelectPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_select"
    bl_label = "Select"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"
    bl_options = {'DEFAULT_CLOSED'}

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

    def draw_header(self, context):
        layout = self.layout
        layout.label(text="My Select Panel")

    def draw(self, context):
        layout = self.layout

        box = layout.box()
        box.label(text="Selection Tools")
        box.operator("object.select_all").action = 'TOGGLE'
        row = box.row()
        row.operator("object.select_all").action = 'INVERT'
        row.operator("object.select_random")

bpy.utils.register_class(ObjectSelectPanel)
```
user: How do I use Brush Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: # Brush Settings

[[image reference removed]](../../../_images/sculpt-paint_weight-paint_tool-settings_brush-settings_brush-panel.png)

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.html)
:   General and advanced settings.

[Stroke](../../brush/stroke.html)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.html)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.html)
:   Cursor and appearance settings.
user: Provide the full official documentation entry for Tool Context, preserving all code examples.

assistant: Because tool node groups have different settings than modifier node groups, you need to change
the [Node Tree Sub-Type](../../editors/geometry_node.html#bpy-types-spacenodeeditor-node-tree-sub-type) in the Geometry Node Editor’s header
to *Tool* in order to edit them.

When this type is selected, the [data-block menu](../../interface/controls/templates/data_block.html#ui-data-block) in the editor’s
header will only show the node groups that have the
[Tool Usage](../../interface/controls/nodes/groups.html#bpy-types-geometrynodetree-is-tool) enabled.

- If you create a new node group while in the *Tool* editor type, the *Tool* Usage will be
  enabled automatically.
- If you want to convert an existing modifier node group, you need to manually enable the
  *Tool* Usage in the Sidebar (and optionally disable the *Modifier* Usage) before switching
  to the *Tool* editor type. Also make sure to set up the [Supported Modes & Object Types](#modeling-geometry-nodes-tools-contexts).
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`AssetMetaData.tags`](bpy.types.AssetMetaData.html#bpy.types.AssetMetaData.tags "bpy.types.AssetMetaData.tags") - [`AssetTags.new`](bpy.types.AssetTags.html#bpy.types.AssetTags.new "bpy.types.AssetTags.new") | - [`AssetTags.remove`](bpy.types.AssetTags.html#bpy.types.AssetTags.remove "bpy.types.AssetTags.remove") |
user: Provide the full official documentation entry for Popup Menus, preserving all code examples.

assistant: [image reference removed]

Image menu in the Header of the Image editor.

Popup menus list [Operators](../../operators.html) which can be executed by selecting with `LMB`
or using the generated shortcut indicated by the underlined character of the operator name.
All menu entries show any relevant shortcut keys, which can be executed without opening the menu.

All popup menus can be searched by pressing `Spacebar` and typing the name of the operator in the menu.
If a popup menu has “Search” as one of the items, the menu can be searched without having to press `Spacebar`
first.

All popup menus of an editor can be searched using the [Menu Search](../../operators.html#bpy-ops-wm-search-menu) feature.

### Collapsing Menus

Sometimes it’s helpful to gain some extra horizontal space in the header by collapsing menus.
This can be accessed from the header context menu:
click `RMB` on the header and uncheck the *Show Menus checkbox*.

|  |  |
| --- | --- |
| ../../../_images/interface_controls_buttons_menu_header_uncheck_show_menus_checkbox.png   Right-click on any of the header menus. | ../../../_images/interface_controls_buttons_menus_header-menu-collapsed.png   Access the menu from the collapsed icon. |
user: Give a detailed overview of Spine, Head & Tail: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

### Spine

The [spine](rig_types/spines.xhtml#rigify-rigs-spines-basic-spine) sub-rig provides a cube shaped torso control with
switchable parent, and bent circle shaped hip and chest controls subordinate to it. For low level deformation
tweak controls are provided.

The torso control can optionally be accompanied with a custom pivot control. The rig can also optionally
provide a full set of FK controls that are subordinate to the normal simplified ones, but above tweaks.

The rig properties panel for the spine controls usually includes options for the head and/or tail as well.

[image reference removed]

### Head

The [head](rig_types/spines.xhtml#rigify-rigs-spines-super-head) sub-rig attaches to the end of the spine, and provides
rotational controls for the head and neck, as well as tweaks for fine control of the neck.

If the neck is three or more bones long, an additonal tweak-like translational
neck bend control is provided (the widget looks like a circle with arrows).

The properties panel contains the following options:

Neck Follow Slider
:   [image reference removed]

    This slider controls the rotations isolation for the neck bones.
    The neck will follow the orientation of the Torso when set to 0, and the Chest when set to 1.

Head Follow Slider
:   [image reference removed]

    This slider controls the rotations isolation for the head.
    The head will follow the orientation of the Torso when set to 0, and the Chest when set to 1.

### Tail

The [tail](rig_types/spines.xhtml#rigify-rigs-spines-basic-tail) sub-rig attaches to the start of the spine, and provides
FK controls for the tail, as well as a master control that replicates its local rotation around certain axes
to all individual bones.

The properties panel contains the following options:

Tail Follow Slider
:   This slider controls the rotations isolation for the tail.
    The tail will follow the orientation of the Torso when set to 0, and the Hips when set to 1.
user: How do I use Brush Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: ### General

Normal Radius
:   Higher by default. This ensures that the brush does not change directions to sporadically during a stroke.
    More info at [Normal Radius](../../brush/brush_settings.xhtml#bpy-types-brush-normal-radius-factor)

Tip Roundness
:   Very low by default for a square shape for more deliberate shaping.
    More info at [Tip Roundness](../../brush/brush_settings.xhtml#bpy-types-brush-tip-roundness)
user: Describe Light Probes from the Blender manual or Python API, including usage steps and snippets.

assistant: - EEVEE supports up to 128 active light probe spheres.
- EEVEE supports up to 16 active light probe planes inside the view frustum.
- Active light probe volumes must fit inside the
  [Light Probes Volume Memory Pool](../render_settings/performance.xhtml#bpy-types-sceneeevee-gi-irradiance-pool-size).
user: Explain Working Offline in complete detail according to the official Blender documentation.

assistant: For security or other reasons, workstation may not have internet access.

By default Blender does not access the internet, however this can be
enabled in the System preferences with the
[Online Access](../editors/preferences/system.xhtml#bpy-types-preferencessystem-use-online-access) option.

Working offline can be enforced by running with the `--offline-mode`
[command line argument](command_line/arguments.xhtml#command-line-args-network-options). Users
will then be unable to enable online access in the preferences.
user: Describe ShaderNodeFresnel(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeFresnel(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.ShaderNodeFresnel(*ShaderNode*)
:   Produce a blending factor depending on the angle between the surface normal and the view direction using Fresnel equations.
    Typically used for mixing reflections at grazing angles

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

assistant: |  |  |
| --- | --- |
| - [`GizmoGroup.setup_keymap`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.setup_keymap "bpy.types.GizmoGroup.setup_keymap") - [`KeyConfigurations.active`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.active "bpy.types.KeyConfigurations.active") - [`KeyConfigurations.addon`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.addon "bpy.types.KeyConfigurations.addon") - [`KeyConfigurations.default`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.default "bpy.types.KeyConfigurations.default") | - [`KeyConfigurations.new`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.new "bpy.types.KeyConfigurations.new") - [`KeyConfigurations.remove`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.remove "bpy.types.KeyConfigurations.remove") - [`KeyConfigurations.user`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.user "bpy.types.KeyConfigurations.user") - [`WindowManager.keyconfigs`](bpy.types.WindowManager.html#bpy.types.WindowManager.keyconfigs "bpy.types.WindowManager.keyconfigs") |
user: Provide the full official documentation entry for Run-Time Optimizations, preserving all code examples.

assistant: When executing shaders, a special optimization is applied to Mix Shader nodes.
If Factor evaluates to 0 or 1, any nodes that are only reachable via the unused branch of the mix are not evaluated.

This can substantially reduce the performance cost of combining multiple materials
in one shader with a Color Attribute, texture, or other input used as a switch.
user: Show practical ways to work with TextureNodeTexClouds(TextureNode) in a Blender add-on or script – include code.

assistant: # TextureNodeTexClouds(TextureNode)

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"), [`TextureNode`](bpy.types.TextureNode.html#bpy.types.TextureNode "bpy.types.TextureNode")

*class* bpy.types.TextureNodeTexClouds(*TextureNode*)
:   *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: Give a detailed overview of Hook Modifier: syntax, arguments, return values, common patterns.

assistant: # Hook Modifier

The *Hook* modifier is used to deform a mesh, curve or lattice using another object
(usually an empty or a bone but it can be any object).
As an object specified as hook moves, it pulls vertices or control points from the geometry with it.
You can think of it as animated
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml).

While hooks do not give you the fine control over vertices movement that shape keys do,
they have the advantage that you can select vertices directly for manipulation.

To assign selected vertices (in Edit Mode) you can use the *Assign* button on the modifier panel
or use the [Add Hook](../../meshes/editing/vertex/hooks.xhtml#bpy-ops-object-hook-add-selob) menu.
user: Provide the full official documentation entry for Selection Node, preserving all code examples.

assistant: # Selection Node

[image reference removed]

The *Selection* node outputs true for geometry that is [selected](../../../../interface/selecting.xhtml), and false elsewhere.

The corresponding data flow node is the [Set Selection Node](../write/set_selection.xhtml).
user: Show practical ways to work with Irregular Track Setup in a Blender add-on or script – include code.

assistant: It might not be possible to track a given feature over the whole duration of the shot.
The feature might be blurred or obscured; it might even move out of sight entirely,
due to deliberate camera movement.
In such a situation, we need *another tracked feature* to take on its role, and we need some *overlap time*
to get a smooth transition without visible jump.

[[image reference removed]](../../../../../_images/movie-clip_tracking_clip_sidebar_stabilization_workflow_irregular-tracks.png)

Irregular Tracks.

The stabilizer is able to deal with gaps and partial coverage within the given tracks.
However, the basic assumption is that each track covers a single,
fixed reference point whenever there is any usable/enabled data.
Thus, you must not “reuse” a given track to follow several different points,
rather you should disable and thus end one track, when tracking this feature is no longer feasible.
You may include “gaps”, when a tracking point is temporarily disabled or unavailable,
but you should start a new track for each distinct new feature to be tracked.

Each track contributes to the overall result by the degree controlled through its *Stab Weight* parameter.
It is evaluated on a per-frame basis, which enables us to control the influence of a track by *animating* this
*Stab Weight*. You may imagine the overall working of the stabilizer as if each tracking point “drags” the image
through a flexible spring: When you turn down the *Stab Weight* of a tracking point,
you decrease the amount of “drag”
it creates. Sometimes the contribution of different tracks has to work partially counter each other.
This effect might be used to cancel out spurious movement, e.g. as caused by perspective.
But when, in such a situation, one of the involved tracks suddenly goes away,
a jump in image position or rotation might be the result. Thus, whenever we notice
a jump at the very frame where some partially covered track starts or ends, we need to soften the transition.
We do so by animating the *Stab Weight* gradually down, so that it reaches zero at the boundary point.
In a similar vein, when we plan a “handover” between several partially covered tracks, we define a *cross-fade* over
the duration where the tracks overlap, again by animating the *Stab Weight* parameters accordingly.
But even with such cross-fade smoothing, some residual movement might remain,
which then needs to be corrected with the *Expected Position*
or *Expected rotation* parameters. It is crucial to avoid “overshooting” movements in such a situation –
always strive at setting the animation keyframes onto precisely the same frame number
for all the tracks and parameters involved.
user: What is LineStyleColorModifiers(bpy_struct) and how is it used in Blender Python scripting?

assistant: # LineStyleColorModifiers(bpy_struct)

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

*class* bpy.types.LineStyleColorModifiers(*bpy_struct*)
:   Color modifiers for changing line colors

    new(*name*, *type*)
    :   Add a color modifier to line style

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the color modifier (not unique)
            - **type** (enum in [Linestyle Color Modifier Type Items](bpy_types_enum_items/linestyle_color_modifier_type_items.html#rna-enum-linestyle-color-modifier-type-items)) – Color modifier type to add

        Returns:
        :   Newly added color modifier

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

    remove(*modifier*)
    :   Remove a color modifier from line style

        Parameters:
        :   **modifier** ([`LineStyleColorModifier`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier "bpy.types.LineStyleColorModifier"), (never None)) – Color modifier to remove

    *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 Notes: syntax, arguments, return values, common patterns.

assistant: It is possible that this node will put out a value set that has values beyond the normal range,
i.e. values greater than one and less than zero.
If you will be using the output to mix with other images in the normal range,
you should clamp the values using the Map Value node (with the Min and Max enabled),
or put through a Color Ramp node (with all normal defaults).

[[image reference removed]](../../../_images/compositing_types_color_bright-contrast_clamp-values.png)

Clamp the values to normal range.

Either of these nodes will scale the values back to normal range.
In the example image, we want to intensify the specular pass.
The bottom thread shows what happens if we do not clamp the values;
the specular pass has a value much less than one in the dark areas;
when added to the medium gray, it makes black. Passing the brightened image through either
the Map Value or the Color Ramp node produces the desired effect.
user: Explain Clay Strips in complete detail according to the official Blender documentation.

assistant: # Clay Strips

Similar to the [Clay](clay.xhtml) brush,
but it uses a square tip shape instead of a round one.

Just like the *Clay* brush, it’s useful for building and removing volumes
and shapes like real clay, because it flattens details as you add/subtract from the surfaces.

Clay Strips is very commonly used for aggressive building of volumes
and deliberate control over shapes on the surface.
This brush alone can be used for a fast rough pass over the entire sculpt,
with additional smoothing or polishing often required afterwards.
This brush can be very versatile with varying stroke directions, repeated strokes
and pen pressure to achieve various results.

If used together with [Dyntopo](../tool_settings/dyntopo.xhtml#bpy-ops-sculpt-dynamic-topology-toggle)
it’s easy to continuously build shapes, even in a single stroke.
user: Give a detailed overview of SpreadsheetTables(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # SpreadsheetTables(bpy_struct)

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

*class* bpy.types.SpreadsheetTables(*bpy_struct*)
:   Active table and persisted state of previously displayed tables

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Spreadsheet

The Spreadsheet editor is used to inspect the geometry attributes of the [active](../glossary/index.xhtml#term-Active) object,
typically in order to debug [geometry nodes](../modeling/geometry_nodes/introduction.xhtml).

[image reference removed]

The Spreadsheet editor.
user: Explain Selecting Bones in complete detail according to the official Blender documentation.

assistant: By clicking on a bone’s body, you will select it
(and hence you will implicitly select its root and tip).

Using `Shift`-click, you can add to/remove from the selection.

You also have some *advanced selection* options, based on their relations.

Pick Shortest Path `Ctrl`-click
:   Selects the path from the active bone to the bone under the mouse.

### Deselecting Connected Bones

There is a subtlety regarding connected bones.

When you have several connected bones selected, if you deselect one bone,
its tip will be deselected, but not its root, if it is also the tip of another selected bone.

To understand this, look at Fig. [Bone deselection in a selected chain.](#fig-rig-bone-select-deselect).

Bone deselection in a selected chain.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_whole-chain.png   A selected chain. | ../../../_images/animation_armatures_bones_selecting_two-bones.png   Two selected bones. |

After `Shift`-clicking “Bone.003”:

- “Bone.003” ‘s tip (which is same as “Bone.004” ‘s root) is deselected.
- “Bone” is “Bone.003” ‘s parent. Therefore, “Bone.003” ‘s root is the same as the tip of “Bone”.
  Since “Bone” is still selected, its tip is selected. Thus the root of “Bone.003” remains selected.
user: Provide the full official documentation entry for Blender 5.0 Python API Documentation, preserving all code examples.

assistant: # Blender 5.0 Python API Documentation

Welcome to the Python API documentation for [Blender](https://www.blender.org), the free and open source 3D creation suite.

This site can be used offline: [Download the full documentation (zipped HTML files)](blender_python_reference_5_0.zip)
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Inset operator options.

Boundary `B`
:   Determines whether open edges will be inset or not.

Offset Even
:   Scale the offset to give a more even thickness.

Offset Relative
:   Scale the offset by lengths of surrounding geometry.

Edge Rail
:   Created vertices slide along the original edges of the inner geometry, instead of the normals.

Thickness
:   Set the size of the offset.

Depth `Ctrl`
:   Raise or lower the newly inset faces to add depth.

Outset `O`
:   Create an outset rather than an inset.
    Causes the geometry to be created surrounding selection (instead of within).

Select Outer
:   Toggle which side of the inset is selected after the operation.

Individual `I`
:   By default the Inset tool operates on the region around selected faces,
    but with this option each selected face can be inset on its own.

Interpolate
:   Interpolate mesh data: e.g. UVs, Color Attribute’s colors, weights, etc.
user: What is Textures and how is it used in Blender Python scripting?

assistant: Limit Size
:   Limit the maximum resolution for pictures used in textured display to save memory.
    The limit options are specified in a square of pixels
    (e.g: the option 256 means a texture of 256×256 pixels). This is useful for game engineers,
    whereas the texture limit matches paging blocks of the textures in the target graphic card memory.

Anisotropic Filtering
:   Sets the level of anisotropic filtering.
    This improves the quality of textures that are rendered at the cost of performance.

Clip Alpha
:   Clip alpha below this threshold in the 3D Viewport.
    Note that, the default is set to a low value to prevent issues on some GPUs.

Image Display Method
:   Method to render images; the following options are supported:

    Automatic:
    :   Automatically use *GLSL* which runs on the GPU for performance but falls back to
        the CPU for large images which might be slow when loaded with the GPU.

    2D Texture:
    :   Uses CPU for display transform and render images as a 2D texture.

    GLSL:
    :   Fastest method using GLSL for display transform and render images as a 2D texture.
user: What is Grease Pencil and how is it used in Blender Python scripting?

assistant: Manhattan
:   The minimum number of pixels the mouse should have moved either
    horizontally or vertically before the movement is recorded.
    Decreasing this should work better for curvy lines.

Euclidean
:   The minimum distance that mouse has to travel before movement is recorded.
user: Provide the full official documentation entry for ShaderNodeVectorTransform(ShaderNode), preserving all code examples.

assistant: # ShaderNodeVectorTransform(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.ShaderNodeVectorTransform(*ShaderNode*)
:   Convert a vector, point, or normal between world, camera, and object coordinate space

    convert_from
    :   Space to convert from

        Type:
        :   enum in [`'WORLD'`, `'OBJECT'`, `'CAMERA'`], default `'WORLD'`

    convert_to
    :   Space to convert to

        Type:
        :   enum in [`'WORLD'`, `'OBJECT'`, `'CAMERA'`], default `'WORLD'`

    vector_type
    :   - `POINT`
          Point – Transform a point.
        - `VECTOR`
          Vector – Transform a direction vector.
        - `NORMAL`
          Normal – Transform a normal vector with unit length.

        Type:
        :   enum in [`'POINT'`, `'VECTOR'`, `'NORMAL'`], default `'VECTOR'`

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

assistant: - Select the *Source* mesh you want to copy data from.
- If the source mesh and modified mesh aren’t overlapping in world space,
  uncheck *Object Transform* (the axes icon next to the source mesh).
- Select which type of data you want to copy (e.g. vertex groups, UV maps…).
- If you only want to copy a specific vertex group/UV map/…, select it in *Layer Selection*.
- If the vertex groups/… you want to copy don’t exist yet on the modified mesh,
  click *Generate Data Layers* to create them.
user: Provide the full official documentation entry for Import Preferences From Previous Version, preserving all code examples.

assistant: Selecting this option will copy preferences from an older version of Blender. Doing so will copy preferences and
startup files from the previous version of Blender and load them. This will include installed add-ons and extensions.

The preferences need to be imported from previous versions because the configuration files of each Blender version are
stored in separate folders. Refer to the [Blender’s Directory Layout](../../advanced/blender_directory_layout.html) page for the location of these
folders.

If you would like to start fresh with the new version, continue to [Create New Preferences](#create-new-preferences).
user: Give a detailed overview of Transform: syntax, arguments, return values, common patterns.

assistant: An F-Curve can be edited by transforming the locations of its keyframes.

Move, Rotate, Scale
:   Like other elements in Blender, keyframes can be
    moved, rotated, and scaled as described in
    [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.html).

Extend `E`
:   Lets you quickly move the selected keyframes that are on a certain side of the Playhead.
    This is handy if you need to, say, move all the keyframes after a certain time point to
    the right to make space for new ones.

    To use this operator, first select some or all keyframes and place your mouse cursor to
    the left or right of the Playhead. Then, press `E`, move the mouse to move (only)
    the keyframes on that side of the Playhead, and press `LMB` to confirm
    (or `RMB` to cancel).

While transforming keyframes, you can hold `Shift` to move them more slowly for
better precision, or `Ctrl` to move them in coarse increments.
user: Describe Recovering Data from the Blender manual or Python API, including usage steps and snippets.

assistant: # Recovering Data

Computer crashes, power outages, or simply forgetting to save can result in the loss or corruption of your work. You
can use Blender’s *Auto Save* feature to reduce the chance of losing files when such events occur.

There are three options to help prevent accidental data loss:

- *Save Prompt* prompts you to save unsaved changes on exit
- *Save Versions* saves additional copies of your blend file with a number appended to the extension
- *Auto Save* saves your file automatically every few minutes (by default, every 2 minutes)
user: Describe Asset Catalogs from the Blender manual or Python API, including usage steps and snippets.

assistant: # Asset Catalogs

Asset Catalogs help you to organize your assets. They look a little bit like file directories,
but they are completely independent of the location of your blend-files.
Assign each asset in a blend-file to its own catalog, or have one big catalog
with all the assets of all the blend-files combined. It’s all up to you.

Similar to [Collections](../../scene_layout/collections/collections.xhtml), catalogs can be nested
i.e. you can have a main catalog that contains several nested catalogs.
For example, this allows you to have a catalog of assets for “Furniture”
with sub-catalogs of “Tables”, “Chairs”, “Lamps”, etc…

For more technical information,
see [Asset Catalogs on the Blender Developer Documentation](https://developer.blender.org/docs/features/asset_system/backend/asset_catalogs/).

[image reference removed]

Example file system and catalog structures.

[image reference removed]

Example file system and catalog structures.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: This add-on allows you to export a UV map as an image:
(UV Editor ‣ UV ‣ Export UV Layout)
It allows you to export to `PNG`, `EPS`, or `SVG` format.
The desired UV faces must be selected in the 3D View, not the UV Editor.

The image will be lines defining the UV edges that are within the default grid of the UV Editor.
Edges outside this boundary, even if selected, will not be shown in the saved graphic.

You can then bring this image into your favorite painting program,
and use it as a transparent reference guide to create a texture.
Then export that image and load it back into Blender as part of a material set-up.
For using images as textures, see the page on
[Image Textures](../../render/materials/legacy_textures/types/image_movie.xhtml).

|  |  |
| --- | --- |
| ../../_images/addons_import-export_mesh-uv-layout_uv-editor.png   A UV layout in the UV Editor. | ../../_images/addons_import-export_mesh-uv-layout_export.png   A UV layout in a paint program. |
user: What is Example and how is it used in Blender Python scripting?

assistant: This example shows you how setup a *Path Animation*.

1. Add an object you want to animate and a path along which this object will move.
   In this example it’s the *Monkey* and the *Bézier Circle*.
2. To parent the monkey to the Bézier circle, first select the monkey then the curve
   (so that the curve is the active object), press `Ctrl`-`P` and select *Follow Path*.
   It will automatically animate *Evaluation Time* and activate *Follow* option
   in the *Path Animation* panel.
3. Select the monkey and
   [Clear Origin](../../../scene_layout/object/editing/clear.xhtml) to reset its offset.
4. You can change the orientation of the monkey by changing
   the [Tracking Axis](../../../scene_layout/object/properties/relations.xhtml).

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_properties_path-animation_example-1.png   Monkey parented to the Bézier Circle. | ../../../_images/modeling_curves_properties_path-animation_example-2.png   The final result. |
user: Provide the full official documentation entry for GeometryNodeInstanceOnPoints(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInstanceOnPoints(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.GeometryNodeInstanceOnPoints(*GeometryNode*)
:   Generate a reference to geometry at each of the input points, without duplicating its underlying data

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

assistant: The outputs of the *Evaluate Closure* node depend on its current configuration:

- **When a closure is connected** – Each output corresponds to an output socket of the *Closure Zone* with the same name.
- **When no closure is connected** – Outputs are defined manually through the *Output Items* section of the Sidebar.
user: Provide the full official documentation entry for ChildOfConstraint(Constraint), preserving all code examples.

assistant: # ChildOfConstraint(Constraint)

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

*class* bpy.types.ChildOfConstraint(*Constraint*)
:   Create constraint-based parent-child relationship

    inverse_matrix
    :   Transformation matrix to apply before

        Type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 items in [-inf, inf], default ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0))

    set_inverse_pending
    :   Set to true to request recalculation of the inverse matrix

        Type:
        :   boolean, default False

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    use_location_x
    :   Use X Location of Parent

        Type:
        :   boolean, default False

    use_location_y
    :   Use Y Location of Parent

        Type:
        :   boolean, default False

    use_location_z
    :   Use Z Location of Parent

        Type:
        :   boolean, default False

    use_rotation_x
    :   Use X Rotation of Parent

        Type:
        :   boolean, default False

    use_rotation_y
    :   Use Y Rotation of Parent

        Type:
        :   boolean, default False

    use_rotation_z
    :   Use Z Rotation of Parent

        Type:
        :   boolean, default False

    use_scale_x
    :   Use X Scale of Parent

        Type:
        :   boolean, default False

    use_scale_y
    :   Use Y Scale of Parent

        Type:
        :   boolean, default False

    use_scale_z
    :   Use Z Scale of Parent

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for ExplodeModifier(Modifier), preserving all code examples.

assistant: # ExplodeModifier(Modifier)

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

*class* bpy.types.ExplodeModifier(*Modifier*)
:   Explosion effect modifier based on a particle system

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    particle_uv
    :   UV map to change with particle age

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

    protect
    :   Clean vertex group edges

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

    show_alive
    :   Show mesh when particles are alive

        Type:
        :   boolean, default True

    show_dead
    :   Show mesh when particles are dead

        Type:
        :   boolean, default True

    show_unborn
    :   Show mesh when particles are unborn

        Type:
        :   boolean, default True

    use_edge_cut
    :   Cut face edges for nicer shrapnel

        Type:
        :   boolean, default False

    use_size
    :   Use particle size for the shrapnel

        Type:
        :   boolean, default False

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Vertex Mass
:   Value for the mass of the hair.

Stiffness
:   Controls the bending stiffness of the hair strands.

    Random
    :   Random stiffness of hair.

Damping
:   Damping of bending motion.
user: Give a detailed overview of Custom Attributes: syntax, arguments, return values, common patterns.

assistant: Vertex groups, UV maps and Color Attributes are available as attributes in geometry nodes.
They are referred to by their name.
Naming collisions (e.g. a vertex group and a UV map with the same name) should be avoided.
If there is a naming collision, only one of the attributes is accessible in geometry nodes.

Attributes with any other name can also be created by nodes, when the name is used for the first time.

Note that geometry nodes does not always produce e.g. vertex groups if a node like
[Join Geometry](geometry/join_geometry.html) is used.
Similarly, if the data type of a vertex group attribute is changed from the initial “Float” type,
the attribute will no longer be a vertex group.