PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Parenting in complete detail according to the official Blender documentation.

assistant: # Parenting

You can edit the relationships between bones (and hence create/modify the chains of bones)
both from the 3D Viewport and the Properties. Whatever method you prefer,
it’s always a matter of deciding, for each bone, if it has to be parented to another one,
and if so, if it should be connected to it.

To parent and/or connect bones, you can:

In the *3D Viewport*, select the bone and *then* its future parent, and press `Ctrl`-`P`
(or Armature ‣ Parent ‣ Make Parent…).
In the small *Make Parent* menu that pops up, choose *Connected*
if you want the child to be connected to its parent, else click on *Keep Offset*.
If you have selected more than two bones, they will all be parented to the last selected one.
If you only select one already-parented bone, or all selected bones are already parented to the last selected one,
your only choice is to connect them, if not already done.
If you select only one non-parented bone, you will get the *Need selected bone(s)* error message…

In the *Properties*, Bones tab, for each selected bone,
you can select its parent in the *Parent* data ID to the upper right corner of its Relations panel.
If you want them to be connected, just enable the checkbox to the right of the list.

Parenting example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_parenting_start.png   The starting armature, with Bone.005 parented and connected to Bone.004. | ../../../../_images/animation_armatures_bones_editing_parenting_unconnected.png   Bone.005 re-parented to Bone.002, but not connected to it (same result, using either `Ctrl`-`P` `2` in 3D Viewport, or the Bones tab settings). |
| ../../../../_images/animation_armatures_bones_editing_parenting_connected.png   Bone.005 parented and connected to Bone.002, using `Ctrl`-`P` `1` in 3D Viewport. | ../../../../_images/animation_armatures_bones_editing_parenting_data-id.png   Bone.005 parented and connected to Bone.002.  Using the Parent data ID of Bone.005 Relations panel. |

To disconnect and/or free bones, you can:

- In a 3D Viewport, select the desired bones, and press `Alt`-`P`
  (or Armature ‣ Parent ‣ Clear Parent…).
  In the small *Clear Parent* menu that pops up, choose *Clear Parent* to completely free all selected bones,
  or *Disconnect Bone* if you just want to break their connections.
- In the Properties, *Bones* tab, for each selected bone, you can select no parent
  in the *Parent* data ID of its Relations panel, to free it completely.
  If you just want to disconnect it from its parent, disable the *Connected* checkbox.

Note that relationships with non-selected children are never modified.
user: Show practical ways to work with Virtual Machines in a Blender add-on or script – include code.

assistant: Running Blender inside a virtual machine is known to have problems when OpenGL drawing calls are forwarded to the host
operating system.

To resolve this, configure the system to use PCI passthrough.

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.

# Information

To find out which graphics card and driver Blender is using, use Help ‣ Save System Info inside
Blender. The OpenGL section will have information about your graphics card, vendor and driver version.
user: Describe LineStyleAlphaModifier_AlongStroke(LineStyleAlphaModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleAlphaModifier_AlongStroke(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_AlongStroke(*LineStyleAlphaModifier*)
:   Change alpha transparency along 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'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-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.LineStyleAlphaModifier_AlongStroke.type "bpy.types.LineStyleAlphaModifier_AlongStroke.type")
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Collection.exporters`](bpy.types.Collection.html#bpy.types.Collection.exporters "bpy.types.Collection.exporters") - [`CollectionExports.new`](bpy.types.CollectionExports.html#bpy.types.CollectionExports.new "bpy.types.CollectionExports.new") | - [`CollectionExports.remove`](bpy.types.CollectionExports.html#bpy.types.CollectionExports.remove "bpy.types.CollectionExports.remove") |
user: How do I use Spin in Blender? Include parameters, examples, warnings and best practices.

assistant: Similar to its [mesh counterpart](../../meshes/tools/spin.html), this operator
extrudes the selected control points several times along a circle that’s centered on
the [3D Cursor](../../../editors/3dview/3d_cursor.html) and parallel to the viewing plane.
The [weights](../structure.html#modeling-surfaces-weight) of the new control points are set up
to produce a circle, and the surface is marked as *Cyclic*, *Bézier*, and *Endpoint*
in the extrusion direction (see [Active Spline](../properties/active_spline.html)).
user: Give a detailed overview of Toggle Cyclic: syntax, arguments, return values, common patterns.

assistant: Opens a popover menu with the options *Cyclic U* and *Cyclic V*. The surface is made
cyclic (closed) or non-cyclic (open) in the corresponding direction.

If a surface is cyclic, the last row or column of its control point grid is connected
back to the first. A cylinder is cyclic along either the U or V direction, while
a sphere is cyclic along both.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

Hardness
:   Slightly higher by default. This makes the profile of the brush more noticeable.
    More info at [Hardness](../../brush/brush_settings.xhtml#bpy-types-brush-hardness)

Auto-Smooth
:   Enabled by default for a consistent smoothing effect.
    With lower brush strength (for example with lower pen pressure) the smoothing effect will be more noticeable
    and can be used to create and then blend/polish shapes in a single stroke.
    Enable Pressure to modulate the use of auto-smooth even more with pen inputs.
    More info at [Auto-Smooth](../../brush/brush_settings.xhtml#bpy-types-brush-auto-smooth-factor)
user: Give a detailed overview of Color Palette: syntax, arguments, return values, common patterns.

assistant: # Color Palette

[image reference removed]

Color Palette.

Color Palettes are a way of storing a brush’s color so that it can be used at a later time.
This is useful when working with several colors at once.

Palette
:   A [Data-Block Menu](data_block.xhtml#ui-data-block) to select a palette.

(New Pallet Color)
:   Adds the current brush’s primary *Color* to the palette.

(Delete Pallet Color)
:   Removes the currently selected color from the palette.

/ (Move Pallet Color)
:   Moves the selected color up/down one position.

(Sort By)
:   Sort Colors by Hue, Saturation, Value, Luminance.

Color List
:   Each color that belongs to the palette is presented in a list.
    Clicking on a color will change the brush’s primary *Color* to that color.
user: Give a detailed overview of In Edit Mode: syntax, arguments, return values, common patterns.

assistant: The pivot point becomes the center of the bounding box around the selected mesh elements.

[image reference removed]

The effects of rotation in different mesh selection modes.
The pivot point is shown by a yellow circle.

Median Point may again give a different result.

[image reference removed]

Difference between “Bounding Box Center” (left) and “Median Point” (right).
user: How do I use Poles by Count in Blender? Include parameters, examples, warnings and best practices.

assistant: Finds vertices that are a [pole](../../../glossary/index.html#term-Pole), namely vertices that are connected to an irregular
number of edges. Then, selects either those poles (in vertex selection mode) or the
edges/faces connected to them (in edge/face selection mode).

|  |  |
| --- | --- |
| ../../../_images/modeling_meshes_editing_face_select_by_pole_count_before.webp   Before selecting poles. | ../../../_images/modeling_meshes_editing_face_select_by_pole_count_after.webp   After selecting poles. |

Pole Count
:   Specifies the number of edges a vertex must (not) have to be considered a pole.

Type
:   Defines the comparison method for determining poles:

    Less Than:
    :   Find vertices that have fewer edges than *Pole Count*.

    Equal To:
    :   Find vertices that have exactly *Pole Count* edges.

    Greater Than:
    :   Find vertices that have more edges than *Pole Count*.

    Not Equal To:
    :   Find vertices that have more or fewer edges than *Pole Count*.

Extend
:   Adds to the existing selection rather than replacing it.

Exclude Non Manifold
:   Skips poles that are part of [non-manifold](../../../glossary/index.html#term-Non-manifold) geometry.
user: Provide the full official documentation entry for Freestyle, preserving all code examples.

assistant: # Freestyle

There is only one view map per view layer. It controls the edge detection parameters.
Freestyle can be enabled/disabled per View Layer by toggling the checkbox in the panel header.

[image reference removed]

View Layer: Freestyle panel.

Control Mode
:   Which detected edges are actually rendered, and how, can be controlled either through:

    Parameter Editor Mode:
    :   Lines are rendered via parameters defined in a user-friendly interface
        to define and control Line Sets and line styles.

        A view map (hence a view layer) can have multiple Line Sets,
        and each line set is linked to one line style.

    Python Scripting Mode:
    :   Lines are rendered via [Python scripting](../python.html), powerful but complex.

View Map Cache
:   An option to reuse a previously computed view map for subsequent rendering.
    The cache is automatically updated when the mesh geometry of the input 3D scene has been changed.

    This functionality offers a major performance boost for Freestyle animation rendering
    when the camera-space mesh geometry is static, as well as for repeated still renders
    with updates of line stylization options.

    Although the *View Map Cache* checkbox is a view layer option,
    the cache memory is shared by all view layers and scenes.
    This means that if Freestyle is used for two or more view layers
    (possibly in different scenes through the Compositor),
    then the cached view map for one view layer is replaced by a new view map
    for another view layer and hence no performance gain is expected.

As Render Pass
:   Freestyle lines will not immediately be visible on top of the render image.
    Instead, Freestyle lines are rendered as a [Render Pass](../../layers/passes.html)
    which can be composited with the rendered image with an Alpha Over node.
user: What is Selecting Curve Elements and how is it used in Blender Python scripting?

assistant: # Selecting Curve Elements

This page discusses specific selecting tools for curve objects in Edit Mode.
The Curve Edit more also uses the general select tools used which are described
in the [interface section](../../interface/selecting.html).

Curve selection in *Edit Mode* has fewer options than with meshes.
Mainly this is, because there is only one selectable element type, the control points
(no select mode needed here…). These points are a bit more complex than simple vertices,
however, especially for Bézier curves, as there is the central vertex, and its two handles…

The basic tools are the same as with [meshes](../meshes/selecting/index.html),
so you can select a simple control point with the `LMB`,
add to current selection with `Shift`-`LMB`, Box Select `B`, and so on.

One word about the Bézier control points: when you select the main central vertex,
the two handles are automatically selected too, so you can move it as a whole,
without creating an angle in the curve. However, when you select a handle,
only this vertex is selected, allowing you to modify this control vector…

Note that, unlike mesh edges, you cannot directly select a segment. Instead,
select all of the control points that make up the segment you want to edit.
user: How do I use Object in Blender? Include parameters, examples, warnings and best practices.

assistant: The Viewport Display panel in the Object Properties has several settings that
are used by the Workbench Engine.

Shadow
:   When the *Shadow* in the [Options](options.html) is enabled
    this object will cast a shadow.

In Front
:   When checked the object will be rendered in front of the other objects in the scene.

Color
:   The color to render the object in when object color needs to be rendered.
    The alpha channel can be used to render the object transparent.
user: How do I use Delete Geometry Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Delete Geometry Node

[image reference removed]

The *Delete Geometry* node removes the selected part of a geometry.
It behaves similarly to the [Delete](../../../meshes/editing/mesh/delete.xhtml#bpy-ops-mesh-delete) tool in Edit Mode.
The type of elements to be deleted can be specified with the domain and mode properties.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: # Options

[image reference removed]

Paint options.

The weight paint options change the overall brush behavior.

Auto Normalize
:   Ensures that all deforming vertex groups add up to one while painting.
    When this option is turned off, then all weights of a vertex can have any value between 0 and 1.
    However, when vertex groups are used as deform groups for character animation
    then Blender always interprets the weight values relative to each other.
    That is, Blender always does a normalization over all deform bones.
    Hence in practice it is not necessary to maintain a strict normalization and
    further normalizing weights should not affect animation at all.

    This option works most intuitively when used to maintain normalization while
    painting on top of weights that are already normalized with another tool.

Lock-Relative
:   Displays bone-deforming groups as if all locked deform groups were deleted,
    and the remaining ones were re-normalized.
    This is intended for use when balancing weights within a group of bones while all other bones are locked.
    With this option you can also temporarily view non-normalized weights as if they were normalized,
    without actually changing the values.

Multi-Paint
:   Paint on all selected vertex groups simultaneously, in a way that preserves their relative influence.
    This can be useful when tweaking weights in an area that is affected by more than three bones at once,
    e.g. certain areas on a character’s face.

    This option is only useful in the *Armature* tab, where you can select multiple vertex groups
    by selecting multiple pose bones. Once at least two vertex groups are selected,
    viewport colors and paint logic switch to Multi-Paint mode,
    using the sum of the selected groups’ weights if *Auto Normalize* is enabled,
    and the average otherwise. Any paint operations aimed at this collective weight are applied to
    individual vertex group weights in such way that their ratio stays the same.

    Since the ratio is undefined if all weights are zero, Multi-Paint cannot operate on
    vertices that do not have any weight assigned to the relevant vertex groups.
    For this reason it also does not allow reducing the weight all the way to zero.
    When used with *X Mirror*, it only guarantees completely a symmetrical result
    if weights are initially symmetrical.

Restrict
:   This option limits the influence of painting to vertices (even with weight 0)
    belonging to the selected vertex group.
user: Describe Include & Exclude from the Blender manual or Python API, including usage steps and snippets.

assistant: Light receiver/blocker objects can be set to be either included or excluded.
The behavior is as follows:

- If only included objects are specified, the light only affects those objects.
- If only excluded objects are specified, the light affects all objects in the scene except those specified.
- If both included and excluded objects are specified, the light affects only included objects minus the excluded
  objects. This can be used to for example set a character collection to be included, and then exclude specific
  objects part of the character.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Mesh 1/2
:   Standard geometry input.

Self Intersection Exact Solver
:   Correctly calculates cases when one or both operands have self-intersections.
    This involves more calculations making the node slower.

Hole Tolerant Exact Solver
:   Optimizes the Boolean output for [Non-manifold](../../../../glossary/index.html#term-Non-manifold) geometry
    at the cost of increased computational time.
    Because of the performance impact, this option should only be enabled
    when the solver demonstrates errors with non-manifold geometry.
user: Explain Split in complete detail according to the official Blender documentation.

assistant: Selection `Y`
:   Splits (disconnects) the selection from the rest of the UV.
    The border edge to any non-selected elements are duplicated.

    Note that the “copy” is left exactly at the same position as the original,
    so you must move it to see it clearly.
user: Show practical ways to work with Cloth Sculpting in a Blender add-on or script – include code.

assistant: # Cloth Sculpting

Instead of sculpting cloth manually or creating complex physics simulation setups,
there are various tools directly in sculpt mode that offer a simplified
[Cloth Physics Simulation](../../../physics/cloth/index.xhtml).

[image reference removed]

This has various advantages but is especially useful for base mesh creation and larger clothing folds and draping.
Detailing is possible, but the slower performance on high resolution meshes and simplified cloth physics
might not lead to desirable results.

The resolution of the topology is mainly responsible for the size of the folds
and detail level of the simulation. So an optimal and evenly distributed topology is important.

Many sculpting features are supported, so for example [Masked](../editing/mask.xhtml#sculpt-mask-menu) vertices
are [pinned](../../../physics/cloth/settings/shape.xhtml) in the simulation.
Another example is with [auto-masked](../controls.xhtml) face set boundaries.
The sculpt mode [gravity](../tool_settings/options.xhtml#bpy-types-sculpt-gravity) factor is also applied on the cloth physics.

The main brushes and tools for this feature are the [Cloth Brush](../brushes/cloth.xhtml)
and [Cloth Filter](../tools/cloth_filter.xhtml),
but other transform brushes like [Pose](../brushes/pose.xhtml) and
[Boundary](../brushes/boundary.xhtml) also support cloth sculpting in the brush settings.

A demo file for trying out the various brushes and tools is available
[here](https://www.blender.org/download/demo-files/#sculpting).
user: Provide the full official documentation entry for Keyed, preserving all code examples.

assistant: # Keyed

The path of Keyed particles is determined between particles of any two (or more) particle systems.
This allows the creation of a chains of systems to create long strands or groovy moving particles.
Basically the particles have no dynamics but are interpolated from one system to the next each frame.

To setup *Keyed* particles you need at least two particle systems in the *Keys* list.
user: Explain LineStyleAlphaModifier_AlongStroke(LineStyleAlphaModifier) in complete detail according to the official Blender documentation.

assistant: # LineStyleAlphaModifier_AlongStroke(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_AlongStroke(*LineStyleAlphaModifier*)
:   Change alpha transparency along 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'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-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.LineStyleAlphaModifier_AlongStroke.type "bpy.types.LineStyleAlphaModifier_AlongStroke.type")
user: Describe Mask Gesture Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mask Gesture Tools

Mask gesture tools apply a constant value to all selected vertices within the selection area.
By default, these tools fully mask each vertex. Holding `Ctrl` while performing the selection
clears the mask.

All mask gesture tools can be activated in the Toolbar and are comprised of the following:
user: Give a detailed overview of FModifierEnvelopeControlPoints(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # FModifierEnvelopeControlPoints(bpy_struct)

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

*class* bpy.types.FModifierEnvelopeControlPoints(*bpy_struct*)
:   Control points defining the shape of the envelope

    add(*frame*)
    :   Add a control point to a FModifierEnvelope

        Parameters:
        :   **frame** (*float in* *[**-inf**,* *inf**]*) – Frame to add this control-point

        Returns:
        :   Newly created control-point

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

    remove(*point*)
    :   Remove a control-point from an FModifierEnvelope

        Parameters:
        :   **point** ([`FModifierEnvelopeControlPoint`](bpy.types.FModifierEnvelopeControlPoint.html#bpy.types.FModifierEnvelopeControlPoint "bpy.types.FModifierEnvelopeControlPoint"), (never None)) – Control-point 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: Provide the full official documentation entry for Editing, preserving all code examples.

assistant: An empty can only be edited in Object Mode, which includes its transformation and parenting properties.
For other tools see the [Object section](../scene_layout/object/index.xhtml).

Apply Scale `Ctrl`-`A`
:   While empties don’t exactly have any object data attached to them which can be used for supporting
    “true” apply scale (i.e. with non-uniform scaling), they do have *Display Size* which controls how
    large the empties are displayed (before scaling). This works by taking the scale factor on the most-scaled axis,
    and combines this with the existing empty *Display Size* to maintain the correct dimensions on that axis.
user: Provide the full official documentation entry for Package Management, preserving all code examples.

assistant: ### Subcommand: `list`

usage:

```
blender --command extension list [-h] [-s]
```

List packages from all enabled repositories.

options:
:   `-h, --help`
    :   show this help message and exit

    `-s, --sync`
    :   Sync the remote directory before performing the action.

### Subcommand: `sync`

usage:

```
blender --command extension sync [-h]
```

Download package information for remote repositories.

options:
:   `-h, --help`
    :   show this help message and exit

### Subcommand: `update`

usage:

```
blender --command extension update [-h] [-s]
```

Download and update any outdated packages.

options:
:   `-h, --help`
    :   show this help message and exit

    `-s, --sync`
    :   Sync the remote directory before performing the action.

### Subcommand: `install`

usage:

```
blender --command extension install [-h] [-s] [-e] [--no-prefs]
                                    PACKAGES
```

positional arguments:
:   PACKAGES:
    :   The packages to operate on (separated by `,` without spaces).

options:
:   `-h, --help`
    :   show this help message and exit

    `-s, --sync`
    :   Sync the remote directory before performing the action.

    `-e, --enable`
    :   Enable the extension after installation.

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.

### Subcommand: `install-file`

usage:

```
blender --command extension install-file [-h] -r REPO [-e] [--no-prefs]
                                         FILE
```

Install a package file into a user repository.

positional arguments:
:   FILE:
    :   The packages file.

options:
:   `-h, --help`
    :   show this help message and exit

    `-r REPO, --repo REPO`
    :   The repository identifier.

    `-e, --enable`
    :   Enable the extension after installation.

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.

### Subcommand: `remove`

usage:

```
blender --command extension remove [-h] [--no-prefs] PACKAGES
```

Disable & remove package(s).

positional arguments:
:   PACKAGES:
    :   The packages to operate on (separated by `,` without spaces).

options:
:   `-h, --help`
    :   show this help message and exit

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.
user: What is Lights and how is it used in Blender Python scripting?

assistant: - Lights can only have one color and do not support light node trees.
- Unlike in Cycles, the [Size](../../lights/light_object.xhtml#bpy-types-spotlight-shadow-soft-size)
  of spot lights does not change the softness of the cone.
- The area light [Beam spread](../../lights/light_object.xhtml#bpy-types-spotlight-spot-size) option is not supported.
user: Give a detailed overview of Controls: syntax, arguments, return values, common patterns.

assistant: Tabs
:   Click on the tabs to switch between workspaces.
    Double-click a tab to rename the workspace.

Add Workspace
:   Adds a new workspace from a predefined template (e.g. *Modeling*, *Sculpting*, *Compositing*).

Context Menu `RMB`

Duplicate
:   Makes a copy of the selected workspace, including its screen layout and editors.

Delete
:   Deletes the selected workspace.
    If it is the last workspace, it cannot be removed.

Reorder to Front/Back
:   Moves the workspace tab to the first (front) or last (back) position in the tab list.

Previous Workspace `Ctrl`-`PageUp`
:   Activates the workspace immediately to the left of the current one.

Next Workspace `Ctrl`-`PageDown`
:   Activates the workspace immediately to the right of the current one.

Delete Other Workspaces
:   Removes all workspaces except the one that was right-clicked on.
user: Provide the full official documentation entry for Tips, preserving all code examples.

assistant: - To get the patch file, add .patch to the end of the URL of the pull request. Example:

  ```
  https://projects.blender.org/blender/blender-manual/pulls/104892.patch
  ```
- Checkout a pull request into a detached head (not leaving behind a branch). Example:

  ```
  git fetch -q origin +refs/pull/104892/head: ; git checkout -qf FETCH_HEAD
  ```
user: Provide the full official documentation entry for New Edge/Face from Vertices, preserving all code examples.

assistant: # New Edge/Face from Vertices

This is a context-sensitive tool which creates geometry by filling in the selection.
When only two vertices are selected it will create an edge, otherwise it will create faces.

The typical use case is to select vertices and press `F`,
yet Blender also supports creating faces from different selections to help to
quickly build up geometry.
user: Show practical ways to work with Extrude Edges in a Blender add-on or script – include code.

assistant: # Extrude Edges

Extrude edges as individual edges.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_extrude-edges_before.png   Edge selected. | ../../../../_images/modeling_meshes_editing_edge_extrude-edges_after.png   Edge extruded. |
user: What is GeometryNodeInputSplineCyclic(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeInputSplineCyclic(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.GeometryNodeInputSplineCyclic(*GeometryNode*)
:   Retrieve whether each spline endpoint connects to the beginning

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

assistant: Depth Order
:   Defines how the strokes are ordered in 3D space (for objects not displayed *In Front*).

    2D Layers:
    :   The Strokes drawing order respect the order of the 2D layers list (top to bottom)
        and ignores the real position of the strokes in 3D space.
        See [2D Layers](../../../../grease_pencil/properties/layers.xhtml) for more information.

    3D Location:
    :   The strokes drawing order is based on the stroke location in 3D space.
user: What is AnimViz(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AnimViz(bpy_struct)

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

*class* bpy.types.AnimViz(*bpy_struct*)
:   Settings for the visualization of motion

    motion_path
    :   Motion Path settings for visualization

        Type:
        :   [`AnimVizMotionPaths`](bpy.types.AnimVizMotionPaths.html#bpy.types.AnimVizMotionPaths "bpy.types.AnimVizMotionPaths"), (readonly, 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: Describe Player Options from the Blender manual or Python API, including usage steps and snippets.

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

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

    *Viewing the animation from a different perspective can help you see the animation with “fresh eyes”.*
user: Provide the full official documentation entry for Grid, preserving all code examples.

assistant: A regular grid composed of quadrilateral faces, useful as a base for landscapes, cloth, or organic surfaces.
You can increase the number of subdivisions to create a more detailed mesh suitable for sculpting or simulation.

X Subdivisions
:   Number of face spans along the X axis.

Y Subdivisions
:   Number of face spans along the Y axis.

Size
:   Sets the width and height of the plane (the full extent from edge to edge).
user: Provide the full official documentation entry for Property Subtype Number Array Items, preserving all code examples.

assistant: # Property Subtype Number Array Items

COLOR:
:   Linear Color.

    Color in the scene linear working color space.

TRANSLATION:
:   Translation.

DIRECTION:
:   Direction.

VELOCITY:
:   Velocity.

ACCELERATION:
:   Acceleration.

MATRIX:
:   Matrix.

EULER:
:   Euler Angles.

    Euler rotation angles in radians.

QUATERNION:
:   Quaternion.

    Quaternion rotation (affects NLA blending).

AXISANGLE:
:   Axis-Angle.

    Angle and axis to rotate around.

XYZ:
:   XYZ.

XYZ_LENGTH:
:   XYZ Length.

COLOR_GAMMA:
:   sRGB Color.

    Color in sRGB color space (mainly for user interface colors).

COORDINATES:
:   Coordinates.

LAYER:
:   Layer.

LAYER_MEMBER:
:   Layer Member.

NONE:
:   None.
user: Provide the full official documentation entry for IntAttributeValue(bpy_struct), preserving all code examples.

assistant: # IntAttributeValue(bpy_struct)

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

*class* bpy.types.IntAttributeValue(*bpy_struct*)
:   Integer value in geometry attribute

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe WorldLighting(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # WorldLighting(bpy_struct)

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

*class* bpy.types.WorldLighting(*bpy_struct*)
:   Lighting for a World data-block

    ao_factor
    :   Factor for ambient occlusion blending

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

    distance
    :   Length of rays, defines how far away other faces give occlusion effect

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_sheen_example.png   The Sheen shader example. | ../../../_images/render_shader-nodes_shader_sheen_behavior.svg   The Sheen shader behavior. |
user: Describe Domain Size Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Domain Size Node

[image reference removed]

The *Domain Size* outputs the size of an attribute domain on the selected geometry type,
for example, the number of edges in a mesh, or the number of points in a point cloud.

For more information about attribute domains, see the [geometry attributes page](../attributes_reference.xhtml#attribute-domains).
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Triangulate modifier.

Quad Method
:   Beauty
    :   Split the quads in nice triangles, slower method.

    Fixed
    :   Split the quads on their 1st and 3rd vertices.

    Fixed Alternate
    :   Split the quads on their 2nd and 4th vertices.

    Shortest Diagonal
    :   Split the quads along their shortest diagonal.

    Longest Diagonal
    :   Split the quads along their longest diagonal. This is the preferred mode for cloth simulations.

N-gon Method
:   Beauty
    :   Arrange the new triangles nicely, slower method.

    Clip
    :   Splits n-gons using an ear-clipping algorithm
        (the same method of tessellation used for viewport display).

Minimum Vertices
:   Minimum number of vertices a face must have to be triangulated.
    For example, setting this value to 5, will prevent triangulation of [Quads](../../../glossary/index.xhtml#term-Quad)
    and only triangulate [N-gons](../../../glossary/index.xhtml#term-N-gon).
user: How do I use MaskParent(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MaskParent(bpy_struct)

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

*class* bpy.types.MaskParent(*bpy_struct*)
:   Parenting settings for masking element

    id
    :   ID-block to which masking element would be parented to or to its property

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

    id_type
    :   Type of ID-block that can be used

        Type:
        :   enum in [`'MOVIECLIP'`], default `'MOVIECLIP'`

    parent
    :   Name of parent object in specified data-block to which parenting happens

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

    sub_parent
    :   Name of parent sub-object in specified data-block to which parenting happens

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

    type
    :   Parent Type

        Type:
        :   enum in [`'POINT_TRACK'`, `'PLANE_TRACK'`], default `'POINT_TRACK'`

    *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.MaskParent.type "bpy.types.MaskParent.type")
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Mesh
:   The resulting mesh extracted from the grid’s isosurface.
    The mesh follows the region where the grid’s scalar values equal the
    specified *Threshold*, and can be used for further geometry processing or rendering.
user: Give a detailed overview of Texture: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Typical modifier Texture options.

Those options allow to use any kind of image (including parametric ones) to control the modifier’s effect.
Most of the time, only the value (grayscale) of the texture is used,
but in some cases (like with some modes of the [Displace modifier](deform/displace.html#bpy-types-displacemodifier)),
the whole RGB color components might be exploited.

Texture
:   The [texture data-block](../../render/materials/legacy_textures/introduction.html) to use.

Texture Coordinates
:   The texture’s coordinates to get each vertex’ value:

    UV
    :   Take texture coordinates from face UV coordinates.

        UV Map
        :   The [UV Map](../../glossary/index.html#term-UV-Map) from which to take texture coordinates. If the object has no
            UV coordinates, it falls back to the *Local* coordinate system. If this field is blank,
            but there is a UV map available (e.g. just after adding the first UV map to the mesh),
            the currently active UV map will be used.

    Object
    :   Take the texture coordinates from another object’s coordinate system.

        Object
        :   The object from which to take texture coordinates.
            Moving the object will therefore alter the coordinates of the texture mapping.

            If this field is blank, it falls back to the *Local* coordinate system.

    Global
    :   Take the texture coordinates from the global coordinate system.

    Local
    :   Take the texture coordinates from the object’s local coordinate system.

Use Channel
:   Which channel to use as value source
    (only available with a few modifiers currently, others follow the *Intensity* behavior,
    unless otherwise specified).

    Intensity
    :   The average of the RGB channels (if RGB(1.0, 0.0, 0.0) value is 0.33).

    Red/Green/Blue/Alpha
    :   One of the color channels’ values.

    Hue
    :   The hue from the HSV color model
        (i.e; the color in the standard wheel, e.g. blue has a higher hue value than yellow).

    Saturation
    :   The saturation from the HSV color model (e.g. the value for pure red is 1.0, for gray is 0.0).

    Value
    :   The value from the HSV color model.
user: Explain Keymap Information in complete detail according to the official Blender documentation.

assistant: The left side of the Status Bar displays mouse button shortcuts and the keymap of the active tool.
In editors with a Toolbar, tapping `Alt` (or `Option` on macOS)
shows the hotkeys to change to a desired tool.

[image reference removed]