PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Histogram(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Histogram(bpy_struct)

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

*class* bpy.types.Histogram(*bpy_struct*)
:   Statistical view of the levels of color in an image

    mode
    :   Channels to display in the histogram

        - `LUMA`
          Luma – Luma.
        - `RGB`
          RGB – Red Green Blue.
        - `R`
          R – Red.
        - `G`
          G – Green.
        - `B`
          B – Blue.
        - `A`
          A – Alpha.

        Type:
        :   enum in [`'LUMA'`, `'RGB'`, `'R'`, `'G'`, `'B'`, `'A'`], default `'LUMA'`

    show_line
    :   Display lines rather than filled shapes

        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: Describe LineStyleColorModifier_Material(LineStyleColorModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleColorModifier_Material(LineStyleColorModifier)

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

*class* bpy.types.LineStyleColorModifier_Material(*LineStyleColorModifier*)
:   Change line color based on a material attribute

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

        Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    color_ramp
    :   Color ramp used to change line color

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

    material_attribute
    :   Specify which material attribute is used

        Type:
        :   enum in [`'LINE'`, `'LINE_R'`, `'LINE_G'`, `'LINE_B'`, `'LINE_A'`, `'DIFF'`, `'DIFF_R'`, `'DIFF_G'`, `'DIFF_B'`, `'SPEC'`, `'SPEC_R'`, `'SPEC_G'`, `'SPEC_B'`, `'SPEC_HARD'`, `'ALPHA'`], default `'LINE'`

    type
    :   Type of the modifier

        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), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    use_ramp
    :   Use color ramp to map the BW average into an RGB color

        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.LineStyleColorModifier_Material.type "bpy.types.LineStyleColorModifier_Material.type")
user: Explain In Edit Mode in complete detail according to the official Blender documentation.

assistant: In Edit Mode, the Median Point is the averaged-out position of the
selected vertices. This means that the pivot point will shift towards
the area with the densest geometry.

In the example below, the pivot point lies perfectly in the middle
if both cubes have the same number of vertices, but heavily leans towards
the side if one cube is subdivided – even though both cubes still
have the same size.

[image reference removed]

Median points in Edit Mode.
user: Explain Voxelize Grid Node in complete detail according to the official Blender documentation.

assistant: # Voxelize Grid Node

[image reference removed]

The *Voxelize Grid* node converts all active tiles in a sparse voxel grid
into fully populated voxel regions, removing sparseness.

In voxel-based grids such as signed distance fields (SDF) or fog volumes,
inactive areas are often stored as *tiles*—compact representations that save
memory by not allocating individual voxel values. This node expands those tiles
into explicit voxels, making every voxel within an active tile directly
accessible and editable.

This can be useful before performing operations that require dense voxel data,
such as sampling, filtering, or arithmetic operations that depend on
neighboring voxel values.
user: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ShaderFx.name`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.name "bpy.types.ShaderFx.name") - [`ShaderFx.type`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.type "bpy.types.ShaderFx.type") - [`ShaderFx.show_viewport`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_viewport "bpy.types.ShaderFx.show_viewport") | - [`ShaderFx.show_render`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_render "bpy.types.ShaderFx.show_render") - [`ShaderFx.show_in_editmode`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_in_editmode "bpy.types.ShaderFx.show_in_editmode") - [`ShaderFx.show_expanded`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_expanded "bpy.types.ShaderFx.show_expanded") |
user: Show practical ways to work with spines.super_spine in a Blender add-on or script – include code.

assistant: Will create a complete bendy and stretchy b-bones spine system based on bone numbers of
your bone chain and user defined options.

This is a composite wrapper of [spines.basic_spine](#spines-basic-spine), [spines.super_head](#spines-super-head) and [spines.basic_tail](#spines-basic-tail).
Note that for the tail, the direction of the bones is reversed compared to the separate rig.

Requirement: A chain of at least three connected bones (base system).

[image reference removed]

Spine required bones.

Pivot Position (integer)
:   Defines the pivot position for torso and hips.

Head (Boolean)
:   When checked neck and head systems will be added to your spine rig.

    Neck Position (integer)
    :   Defines the bone where the neck system starts. The last bone will always be the head system.
        If neck position is the last bone of the chain, then only the head system will be created ignoring the neck.

Tail (Boolean)
:   When checked tail system will be added to your spine rig.

    Tail Position (integer)
    :   Defines the bone where the tail system starts. The next bone will always be the hips system.

X, Y, Z (Boolean)
:   When generating a tail, specifies which local axis rotations should be replicated along the chain.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.

[image reference removed]

Spine default bones.

[image reference removed]

Spine with tail bones.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Create Quads
:   When creating a new triangle that shares an edge with an existing one,
    automatically [dissolves](../editing/mesh/delete.xhtml#bpy-ops-mesh-dissolve) this edge so you’re left with a quad.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Display As
:   The [Primitives](#primitives) empty type to display in the 3D Viewport.

Size
:   Controls the size of the empties visualization. This does not change its scale, but functions as an offset.
user: Show practical ways to work with ShaderNodeOutputMaterial(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeOutputMaterial(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.ShaderNodeOutputMaterial(*ShaderNode*)
:   Output surface material information for use in rendering

    is_active_output
    :   True if this node is used as the active output

        Type:
        :   boolean, default False

    target
    :   Which renderer and viewport shading types to use the shaders for

        - `ALL`
          All – Use shaders for all renderers and viewports, unless there exists a more specific output.
        - `EEVEE`
          EEVEE – Use shaders for EEVEE renderer.
        - `CYCLES`
          Cycles – Use shaders for Cycles renderer.

        Type:
        :   enum in [`'ALL'`, `'EEVEE'`, `'CYCLES'`], default `'ALL'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # BlendDataNodeTrees(bpy_struct)

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

*class* bpy.types.BlendDataNodeTrees(*bpy_struct*)
:   Collection of node trees

    new(*name*, *type*)
    :   Add a new node tree to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **type** (enum in [`'GeometryNodeTree'`, `'CompositorNodeTree'`, `'ShaderNodeTree'`, `'TextureNodeTree'`]) –

              Type, The type of node_group to add

              - `GeometryNodeTree`
                Geometry Node Editor – Advanced geometry editing and tools creation using nodes.
              - `CompositorNodeTree`
                Compositor – Create effects and post-process renders, images, and the 3D Viewport.
              - `ShaderNodeTree`
                Shader Editor – Edit materials, lights, and world shading using nodes.
              - `TextureNodeTree`
                Texture Node Editor – Edit textures using nodes.

        Returns:
        :   New node tree data-block

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

    remove(*tree*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a node tree from the current blendfile

        Parameters:
        :   - **tree** ([`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree"), (never None)) – Node tree to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this node tree before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this node tree
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this node tree

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Controlling Script Execution in a Blender add-on or script – include code.

assistant: Blender provides a number of ways to control whether scripts
from a blend-file are allowed to automatically execute.

First, the File Browser has the option **Trusted Source** which you can use on
a case-by-case basis to control auto execution.
Since you may forget to set this,
or may open a file without going through the File Browser,
you can change the default (described next).

### Setting Defaults

In the Preferences, there is the toggle to
[Auto Run Python Scripts](../../editors/preferences/save_load.xhtml#bpy-types-preferencesfilepaths-use-scripts-auto-execute).
This means the **Trusted Source** option in the File Browser will be enabled by default,
and scripts can run when blend-files are loaded without using the File Browser.
Once enabled you have the option to exclude certain directories;
a typical configuration would be to trust all paths except for the download directory.

[image reference removed]

The Auto Run Python Scripts checkbox.

### Command Line

You may want to perform batch rendering or some other task from the command line,
running Blender without an interface.
In this case, the Preferences are still used but you may want to override them:

- Enable with `-y` or `--enable-autoexec`
- Disable with `-Y` or `--disable-autoexec`

#### Example

To render an animation in background mode, allowing drivers and other scripts to run:

```
blender --background --enable-autoexec my_movie.blend --render-anim
```
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`CurveProfile.points`](bpy.types.CurveProfile.html#bpy.types.CurveProfile.points "bpy.types.CurveProfile.points") - [`CurveProfile.segments`](bpy.types.CurveProfile.html#bpy.types.CurveProfile.segments "bpy.types.CurveProfile.segments") | - [`CurveProfilePoints.add`](bpy.types.CurveProfilePoints.html#bpy.types.CurveProfilePoints.add "bpy.types.CurveProfilePoints.add") - [`CurveProfilePoints.remove`](bpy.types.CurveProfilePoints.html#bpy.types.CurveProfilePoints.remove "bpy.types.CurveProfilePoints.remove") |
user: Show practical ways to work with Control Point Grid in a Blender add-on or script – include code.

assistant: While a Surface can be compared to a mesh with a
[Subdivision Surface Modifier](../modifiers/generate/subdivision_surface.xhtml),
it’s more restrictive because the control points must be strictly arranged in a grid:
each “row” indicated by a yellow line must have the same number of
control points, and so does each “column” indicated by a pink line.
The only way to extend the surface is by
[extruding](editing/control_points.xhtml) a complete row or column.

The [Active Spline](properties/active_spline.xhtml) panel controls whether
the surface is cyclic (closed) in each direction of the grid, and whether Bézier
or NURBS should be used.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Curves
:   The guide curves with interpolated curves.

Closest Index
:   Index of the closest guide curve for each generated curve.

Closest Weight
:   Weight of the closest guide curve for each generated curve.
user: How do I use Sidebar in Blender? Include parameters, examples, warnings and best practices.

assistant: In the Sidebar, you can define filters so that only the rows matching these filters
are displayed. Click *Add Row Filter* and set up the properties described below.

Enabled
:   Uncheck to temporarily disable the filter.

Column
:   The name of the column to filter on. If there is no column with the specified name,
    the filter will be grayed out and ignored.

    If you want to filter on an attribute from another domain, you can use the
    [Store Named Attribute Node](../modeling/geometry_nodes/attribute/store_named_attribute.html) to create a copy
    that’s converted to the current domain, then filter on that.

Operation
:   For numerical columns, you can select one of the following comparison operators.
    Other columns only support *Equal To*.

    Equal To:
    :   Only display rows whose value for the column is equal to the filter value
        (within the specified threshold).

    Greater Than:
    :   Only display rows whose value for the column is greater than the filter value.

    Less Than:
    :   Only display rows whose value for the column is less than the filter value.

Value
:   The filter value to compare the row value to.

Threshold
:   How much the row’s value is allowed to deviate from the filter value before it is excluded.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: ### Baking

Baking converts high-resolution geometry details, such as sculpted displacement or surface normals,
into 2D texture maps. These maps can then be applied to a lower-resolution mesh to reproduce
the appearance of fine surface detail without the performance cost of dense geometry.

This process is essential for workflows where high-resolution sculpting data is transferred to
low-resolution meshes for rendering or game engines.

To generate a normal or displacement map, use the
[Bake from Multires](../../../render/cycles/baking.xhtml#bpy-types-rendersettings-use-bake-multires) option in the Render panel.
This feature compares two resolution levels of the Multiresolution modifier:

- **Viewport Levels:** Used as the *low-resolution* base mesh.
- **Render Levels:** Used as the *high-resolution* detail mesh.

The difference between these two levels is baked into a texture map.

#### Bake Types

The *Bake Type* determines what kind of surface information is extracted from the Multiresolution modifier.

- **Normals:**
  Bakes surface normal direction differences between the base and detailed levels.
  The resulting normal map encodes lighting information that reproduces fine sculpted detail
  in shading without modifying the actual geometry.
  Ideal for use with normal-mapped materials in Cycles, Eevee, and real-time engines.
- **Displacement:**
  Bakes height differences between the base and high-resolution mesh as a grayscale image.
  Lighter areas represent raised regions and darker areas represent recessed areas.
  This map can be used for *true* displacement in render engines or for parallax/height-based shading.
- **Vector Displacement:**
  Bakes 3D displacement vectors representing the full spatial offset from the base to the detailed surface.
  Unlike regular displacement, this method can capture overhangs and non-vertical displacements,
  providing a more accurate representation of complex sculpted details.

  The resulting texture encodes XYZ displacement in the RGB color channels.
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Modifier.name`](bpy.types.Modifier.html#bpy.types.Modifier.name "bpy.types.Modifier.name") - [`Modifier.type`](bpy.types.Modifier.html#bpy.types.Modifier.type "bpy.types.Modifier.type") - [`Modifier.show_viewport`](bpy.types.Modifier.html#bpy.types.Modifier.show_viewport "bpy.types.Modifier.show_viewport") - [`Modifier.show_render`](bpy.types.Modifier.html#bpy.types.Modifier.show_render "bpy.types.Modifier.show_render") - [`Modifier.show_in_editmode`](bpy.types.Modifier.html#bpy.types.Modifier.show_in_editmode "bpy.types.Modifier.show_in_editmode") - [`Modifier.show_on_cage`](bpy.types.Modifier.html#bpy.types.Modifier.show_on_cage "bpy.types.Modifier.show_on_cage") | - [`Modifier.show_expanded`](bpy.types.Modifier.html#bpy.types.Modifier.show_expanded "bpy.types.Modifier.show_expanded") - [`Modifier.is_active`](bpy.types.Modifier.html#bpy.types.Modifier.is_active "bpy.types.Modifier.is_active") - [`Modifier.use_pin_to_last`](bpy.types.Modifier.html#bpy.types.Modifier.use_pin_to_last "bpy.types.Modifier.use_pin_to_last") - [`Modifier.is_override_data`](bpy.types.Modifier.html#bpy.types.Modifier.is_override_data "bpy.types.Modifier.is_override_data") - [`Modifier.use_apply_on_spline`](bpy.types.Modifier.html#bpy.types.Modifier.use_apply_on_spline "bpy.types.Modifier.use_apply_on_spline") - [`Modifier.execution_time`](bpy.types.Modifier.html#bpy.types.Modifier.execution_time "bpy.types.Modifier.execution_time") - [`Modifier.persistent_uid`](bpy.types.Modifier.html#bpy.types.Modifier.persistent_uid "bpy.types.Modifier.persistent_uid") |
user: Give a detailed overview of Tags and Translations: syntax, arguments, return values, common patterns.

assistant: If you are planning to use a different set of [tags](../tags.xhtml#extensions-tags) than the ones used by
Blender Extensions Platform, remember to submit a pull request to
[tags.py](https://projects.blender.org/blender/blender/src/scripts/modules/_bpy_internal/extensions/tags.py).

This way they can be shown translated within Blender.
user: Provide the full official documentation entry for Braid Hair Curves, preserving all code examples.

assistant: # Braid Hair Curves

The *Braid Hair Curves* node deforms existing hair curves into braided strands by
grouping nearby curves around guide curves. The deformation creates a multi-strand
braid pattern, with options for radius, twist frequency, strand thickness, and an
optional flare or tied ending.

This node is designed for grooming workflows where a few curves act as braid guides,
and surrounding curves are wrapped around them to form a structured braid.
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`UIList.bl_idname`](bpy.types.UIList.html#bpy.types.UIList.bl_idname "bpy.types.UIList.bl_idname") - [`UIList.list_id`](bpy.types.UIList.html#bpy.types.UIList.list_id "bpy.types.UIList.list_id") - [`UIList.layout_type`](bpy.types.UIList.html#bpy.types.UIList.layout_type "bpy.types.UIList.layout_type") - [`UIList.use_filter_show`](bpy.types.UIList.html#bpy.types.UIList.use_filter_show "bpy.types.UIList.use_filter_show") - [`UIList.filter_name`](bpy.types.UIList.html#bpy.types.UIList.filter_name "bpy.types.UIList.filter_name") | - [`UIList.use_filter_invert`](bpy.types.UIList.html#bpy.types.UIList.use_filter_invert "bpy.types.UIList.use_filter_invert") - [`UIList.use_filter_sort_alpha`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_alpha "bpy.types.UIList.use_filter_sort_alpha") - [`UIList.use_filter_sort_reverse`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_reverse "bpy.types.UIList.use_filter_sort_reverse") - [`UIList.use_filter_sort_lock`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_lock "bpy.types.UIList.use_filter_sort_lock") - [`UIList.bitflag_filter_item`](bpy.types.UIList.html#bpy.types.UIList.bitflag_filter_item "bpy.types.UIList.bitflag_filter_item") - [`UIList.bitflag_item_never_show`](bpy.types.UIList.html#bpy.types.UIList.bitflag_item_never_show "bpy.types.UIList.bitflag_item_never_show") |
user: Explain Importing in complete detail according to the official Blender documentation.

assistant: ### General

Scale
:   Value by which to scale the imported objects in relation to the world’s origin.

Scene Unit
:   Apply current scene’s unit (as defined by unit scale) to imported data.

Forward / Up Axis
:   Since many applications use a different axis for pointing upwards, these are axis conversion for these settings,
    Forward and up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y forward, Z up (since the front view looks along the +Y direction).
    For example, it is common for applications to use Y as the up axis, in that case -Z forward, Y up is needed.

### Options

Facet Normals
:   Use (import) facet normals (note that this will still give flat shading).

Validate Mesh
:   Check the imported mesh for corrupt data and fix it if necessary.
    When disabled, erroneous data may cause crashes displaying or editing the meshes.
    This option will make the importing slower but is recommended, as data errors are not always obvious.
user: Explain Line Art in complete detail according to the official Blender documentation.

assistant: # Line Art

The *Line Art* panel is used to enable extra display options for customizing
Line Art rendering for a specific object.

[image reference removed]

Line Art panel.

Usage
:   How the object is loaded into Line Art.
    This property overrides the parent collection’s [Line Art](../../collections/collections.xhtml#scene-layout-collections-line-art) usage.

    Inherit:
    :   No special loading strategy for Line Art.
        Loading of the object is controlled by parent collection’s Line Art settings.

    Include:
    :   Force include the object into Line Art calculation
        even if its parent collection specifies otherwise.

    Intersection Only:
    :   The object will only produce intersection lines in the scene and its own geometry stays invisible.

    Occlusion Only:
    :   The object will only cause occlusion to existing feature lines and its geometry stays invisible.

    Exclude:
    :   The object will not be loaded into Line Art at all.

    No Intersection:
    :   The object will not generate intersection lines on itself or with other objects in scene.

    Force Intersection:
    :   Generate intersection lines even with objects that disabled intersection.

Override Crease
:   Allows the object to have a different crease value than the global one set in the Line Art modifier.

    Crease
    :   Override crease value for the object.

Intersection Priority
:   Assigns an intersection priority value for this object.
    The intersection line will be included into the object with the higher intersection priority value.
user: Explain Package Management in complete detail according to the official Blender documentation.

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: Explain AdjustmentStrip(EffectStrip) in complete detail according to the official Blender documentation.

assistant: # AdjustmentStrip(EffectStrip)

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

*class* bpy.types.AdjustmentStrip(*EffectStrip*)
:   Sequence strip to perform filter adjustments to layers below

    animation_offset_end
    :   Animation end offset (trim end)

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

    animation_offset_start
    :   Animation start offset (trim start)

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

    input_count
    :   Type:
        :   int in [0, inf], default 0, (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: Provide the full official documentation entry for Troubleshooting Graphics Hardware, preserving all code examples.

assistant: # Troubleshooting Graphics Hardware

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Give a detailed overview of Shape: syntax, arguments, return values, common patterns.

assistant: # Shape

[image reference removed]

Shape panel.

Dimensions
:   By default, new curves are set to be 3D, which means that control points can be placed anywhere in 3D space.
    Curves can also be set to 2D which constrain the control points to the curve’s local XY axis.

Resolution Preview/Render U
:   The *resolution* property defines the number of points that are computed between every pair of control points.
    Curves can be made more or less smooth by increasing and decreasing the resolution respectively.
    The *Preview U* setting determines the resolution in the 3D Viewport while the *Render U* setting
    determines the curve’s render resolution. If *Render U* is set to zero (0),
    then the *Preview U* setting is used for both the 3D Viewport and render resolution.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_shape_resolution-3.png   Curves with a resolution of 3. | ../../../_images/modeling_curves_properties_shape_resolution-12.png   Curves with a resolution of 12. |

Twist Method
:   A 3D curve has control points that are not located on the curve’s local XY plane.
    This gives the curve a twist which can affect the curve normals.
    You can alter how the twist of the curve is calculated by choosing from
    *Minimum, Tangent* and *Z-Up* options from the select menu.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_shape_resolution-12.png   Curves with a twist of Minimum. | ../../../_images/modeling_curves_properties_shape_twisting.png   Curves with a twist of Tangent. |

Smooth
:   Interactively removes twists from the curve. This is useful if a curve has noticeable “kinks”
    from over twisting; which can be possible when converting meshes to curves.

Fill Mode
:   Fill determines the way a curve is displayed when it is beveled (see below for details on Beveling).
    When set to *Half* the curve is displayed as half a cylinder.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_shape_fill-half.png   Curves with a fill of Half. | ../../../_images/modeling_curves_properties_shape_fill-full.png   Curves with a fill of Full. |

Curve Deform
:   Radius
    :   Causes the deformed object to be scaled by the set curve radius.
        Utilized when using a curve as a path or when using the [Curve Modifier](../../modifiers/deform/curve.xhtml).

    Stretch
    :   The *Stretch* curve option allows you to let the mesh object stretch, or squeeze, over the entire curve.
        To get the expected result, use this together with the *Bounds Clamp* option.
        Utilized when using the [Curve Modifier](../../modifiers/deform/curve.xhtml).

    Bounds Clamp
    :   When this option is enabled, the object and mesh offset along the deformation axis is ignored.
        This can be useful with the *Stretch* option or when using a negative axis.
        Utilized when using the [Curve Modifier](../../modifiers/deform/curve.xhtml).
user: Show practical ways to work with ActionStrip(bpy_struct) in a Blender add-on or script – include code.

assistant: # ActionStrip(bpy_struct)

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

subclasses —
[`ActionKeyframeStrip`](bpy.types.ActionKeyframeStrip.html#bpy.types.ActionKeyframeStrip "bpy.types.ActionKeyframeStrip")

*class* bpy.types.ActionStrip(*bpy_struct*)
:   type
    :   - `KEYFRAME`
          Keyframe – Strip with a set of F-Curves for each action slot.

        Type:
        :   enum in [`'KEYFRAME'`], default `'KEYFRAME'`, (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](#bpy.types.ActionStrip.type "bpy.types.ActionStrip.type")
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   Standard geometry input.

Group ID
:   Splits the elements of the input geometry into groups which can be sampled individually.

Sample Position
:   The given position to calculate the closest location on the target.

Sample Group ID
:   Determines in which group the closest nearest element is detected.
user: Provide the full official documentation entry for Viewport, preserving all code examples.

assistant: Samples
:   The number of samples to use in the 3D Viewport.
    When setting this to zero the viewport will be resampled continuously.

Temporal Reprojection
:   Reduces noise while moving the viewport or during animation playback. Can leave some ghosting.

Jittered Shadows
:   Enable jittered shadows on the viewport.
    Jittered shadows are always enabled for final renders.
    This also affects any transparent shadows.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

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: Show practical ways to work with NodeTreeInterfaceSocketVectorFactor4D(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketVectorFactor4D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorFactor4D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is FunctionNodeStringLength(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeStringLength(FunctionNode)

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

*class* bpy.types.FunctionNodeStringLength(*FunctionNode*)
:   Output the number of characters in the given string

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Types from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Color Picker Type* determines how colors are visualized and selected.
Different picker types offer alternative layouts for adjusting hue, saturation, and value components.
The choice is a matter of personal preference and workflow.

You can choose the default picker type in the Preferences under
[Interface Preferences](../../../editors/preferences/interface.xhtml#bpy-types-preferencesview-color-picker-type).

Color Picker Types

|  |  |  |
| --- | --- | --- |
| ../../../_images/interface_controls_templates_color-picker_circle-hsv.png   Circle HSV | ../../../_images/interface_controls_templates_color-picker_circle-hsl.png   Circle HSL |  |
| ../../../_images/interface_controls_templates_color-picker_square-sv-h.png   Square (SV + H) | ../../../_images/interface_controls_templates_color-picker_square-hs-v.png   Square (HS + V) | ../../../_images/interface_controls_templates_color-picker_square-hv-s.png   Square (HV + S) |
user: Show practical ways to work with Space Graph Mode Items in a Blender add-on or script – include code.

assistant: # Space Graph Mode Items

FCURVES:
:   Graph Editor.

    Edit animation/keyframes displayed as 2D curves.

DRIVERS:
:   Drivers.

    Define and edit drivers that link properties to custom functions or other data.
user: How do I use Marker Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: [Markers](../../animation/markers.xhtml) are used to denote frames with key points or significant events
within an animation. Like with most animation editors, they’re shown at the bottom.

[image reference removed]

Markers in animation editor.

There are some options that are exclusive to the Dope Sheet editor:

Sync Markers
:   Whether to also move the selected markers when moving the selected keyframes.

Show Pose Markers Action Editor
:   Instead of showing the global scene markers, show the local pose markers (which only exist inside the action).
    While this option is active, the *Add Marker* menu item will also create pose markers instead of scene markers.

Make Markers Local Action Editor
:   Converts the selected scene markers into pose markers,
    making them only visible inside the currently selected action.

For information about the other marker tools, see [Editing Markers](../../animation/markers.xhtml#animation-markers-editing).
user: Show practical ways to work with Playback Controls in a Blender add-on or script – include code.

assistant: The Playback Controls region contains controls and options
related to playback, keying, auto keyframing, and transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.
user: How do I use Bpy.Types.Cloudstexture in Blender? Include parameters, examples, warnings and best practices.

assistant: yright &#169; Blender Authors Made with Furo Report issue on this page On this page CloudsTexture(Texture) CloudsTexture CloudsTexture.cloud_type CloudsTexture.nabla CloudsTexture.noise_basis CloudsTexture.noise_depth CloudsTexture.noise_scale CloudsTexture.noise_type CloudsTexture.users_material CloudsTexture.users_object_modifier CloudsTexture.bl_rna_get_subclass() CloudsTexture.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Provide the full official documentation entry for Set Grease Pencil Softness Node, preserving all code examples.

assistant: # Set Grease Pencil Softness Node

[image reference removed]

The *Set Grease Pencil Softness* node sets a stroke’s softness,
which controls how much a stroke’s edges fade out. Higher softness values create more transparent,
blurred edges, while lower values produce crisper, more defined strokes.
user: What is Multiple Scattering and how is it used in Blender Python scripting?

assistant: Real-world effects such as scattering in clouds or subsurface scattering require many
scattering bounces. However, unbiased rendering of such effects can be noisy, so by default
the number of bounces is zero in Cycles, and no support is available in EEVEE.
The effect you get when rendering with zero volume bounces is what is known as
“single scattering”, the effect from more bounces is “multiple scattering”.

For rendering materials like skin or milk that require multiple scattering,
subsurface scattering is more efficient and easier to control. Particularly the random walk
method can accurately render such materials.

For materials such as clouds or smoke that do not have a well-defined surface,
volume rendering is required. These look best with many scattering bounces,
but in practice one might have to limit the number of bounces to keep render times acceptable.