PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for About Free Software and the GPL, preserving all code examples.

assistant: # About Free Software and the GPL

[image reference removed]

When one hears about “free software”, the first thing that comes to mind might be “no cost”. While this is often true,
the term “free software” as used by the Free Software Foundation (originators of the GNU Project and creators of the
GNU General Public License) is intended to mean “free as in freedom” rather than in the sense of “no cost” (which is
usually referred to as “free as in free beer” or *gratis*). Free software in this sense is software which you are free
to use, copy, modify, redistribute, with no limit. Contrast this with the licensing of most commercial software
packages, where you are allowed to load the software on a single computer, are allowed to make no copies, and never
see the source code. Free software allows incredible freedom to the end user. Since the source code is universally
available, there are also many more chances for bugs to be caught and fixed.

When a program is licensed under the GNU General Public License (the GPL):

- You have the right to use the program for any purpose.
- You have the right to modify the program and have access to the source codes.
- You have the right to copy and distribute the program.
- You have the right to improve the program, and release your own versions.

In return for these rights, you have some responsibilities if you distribute a GPL’d program. These responsibilities
are designed to protect your freedoms and the freedoms of others:

- You must provide a copy of the GPL with the program, so that recipients are aware of their rights under the license.
- You must include the source code or make the source code freely available.
- If you modify the code and distribute the modified version, you must license your modifications available under the
  GPL (or a compatible license).
- You may not restrict the licensing of the program beyond the terms of the GPL (you may not turn a GPL’d program into
  a proprietary product).

For more on the GPL, check its page on the [GNU Project website](https://www.gnu.org/licenses/licenses.html#GPL).
user: What is Select Edge Ring and how is it used in Blender Python scripting?

assistant: Holding `Ctrl`-`Alt` while clicking an edge selects that edge and then expands the selection
as far as possible in the two directions perpendicular to it. (While this of course works for selecting
edge “rings” that go all the way around a mesh, it also works if there’s no ring.)

You can additionally hold `Shift` to extend the current selection rather than replacing it.
user: How do I use Node Bundles in Blender? Include parameters, examples, warnings and best practices.

assistant: # Node Bundles

A *bundle* is a container that groups multiple values into one socket.
This makes it possible to pass many values through
a single link, similar to a *struct* in programming.

Bundles reduce the number of exposed inputs and outputs in a node group,
and can contain mixed data types such as geometry, fields, values, objects,
or even nested bundles.

[image reference removed]

A cube and cylinder combined into a bundle, then separated again.
user: What is Operators and how is it used in Blender Python scripting?

assistant: [[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_editor-functions.png)

Vertex weight operators.

Normalize
:   Recalculates the weights of the active vertex so that they add up to 1.0 while
    retaining their relative magnitude.

Copy
:   Copies all the weights from the active vertex to the other selected vertices.
user: How do I use Voxel Remesher in Blender? Include parameters, examples, warnings and best practices.

assistant: “Voxel remeshing” rebuilds the geometry with a perfectly even distributed topology.
Depending on the set voxel size, this will lead to a lower or higher resolution.

This technique is especially useful to block out the initial shape of an object.
It also has the advantage of removing any overlapping geometry and creating a manifold volume as a result.

[image reference removed]

Any currently used mask, face sets and color attributes will be re-projected on the remeshed result.
Reaching high vertex counts should still be achievable with this technique, depending on the used hardware.

To more easily access this feature, use the shortcuts `R` to define the resolution,
and `Ctrl`-`R` to execute the remeshing.

[image reference removed]
user: Give a detailed overview of ShaderNodeTexBrick(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeTexBrick(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.ShaderNodeTexBrick(*ShaderNode*)
:   Generate a procedural texture producing bricks

    color_mapping
    :   Color mapping settings

        Type:
        :   [`ColorMapping`](bpy.types.ColorMapping.html#bpy.types.ColorMapping "bpy.types.ColorMapping"), (readonly, never None)

    offset
    :   Determines the brick offset of the various rows

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

    offset_frequency
    :   How often rows are offset. A value of 2 gives an even/uneven pattern of rows.

        Type:
        :   int in [1, 99], default 2

    squash
    :   Factor to adjust the brick’s width for particular rows determined by the Offset Frequency

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

    squash_frequency
    :   How often rows consist of “squished” bricks

        Type:
        :   int in [1, 99], default 2

    texture_mapping
    :   Texture coordinate mapping settings

        Type:
        :   [`TexMapping`](bpy.types.TexMapping.html#bpy.types.TexMapping "bpy.types.TexMapping"), (readonly, never None)

    *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 Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Scale X, Y, Z
:   The amount to resize the selection on their respected axis.

Orientation
:   Aligns the transformation axes to a specified orientation constraint.
    See [Transform Orientations](../../../editors/3dview/controls/orientation.html) for more information.

Proportional Editing
:   The extruded face will affect nearby geometry.
    See [Proportional Editing](../../../editors/3dview/controls/proportional_editing.html) for a full reference.
user: Give a detailed overview of Sheen BSDF: syntax, arguments, return values, common patterns.

assistant: # Sheen BSDF

[image reference removed]

Cycles Only

The *Sheen* BSDF
is used to add reflection to materials that have micro surface details such as cloth or dust.
This shader is intended to be layered on top of other shaders such as
[dielectric](../../../glossary/index.xhtml#term-Dielectric-Material) or metallic shader setups.
user: Explain PointCache(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # PointCache(bpy_struct)

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

*class* bpy.types.PointCache(*bpy_struct*)
:   Active point cache for physics simulations

    filepath
    :   Cache file path

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    frame_end
    :   Frame on which the simulation stops

        Type:
        :   int in [1, 1048574], default 0

    frame_start
    :   Frame on which the simulation starts

        Type:
        :   int in [-1048574, 1048574], default 0

    frame_step
    :   Number of frames between cached frames

        Type:
        :   int in [1, 20], default 0

    index
    :   Index number of cache files

        Type:
        :   int in [-1, 100], default 0

    info
    :   Info on current cache status

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

    is_baked
    :   The cache is baked

        Type:
        :   boolean, default False, (readonly)

    is_baking
    :   The cache is being baked

        Type:
        :   boolean, default False, (readonly)

    is_frame_skip
    :   Some frames were skipped while baking/saving that cache

        Type:
        :   boolean, default False, (readonly)

    is_outdated
    :   Type:
        :   boolean, default False, (readonly)

    name
    :   Cache name

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

    point_caches
    :   Type:
        :   [`PointCaches`](bpy.types.PointCaches.html#bpy.types.PointCaches "bpy.types.PointCaches") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`PointCacheItem`](bpy.types.PointCacheItem.html#bpy.types.PointCacheItem "bpy.types.PointCacheItem"), (readonly)

    use_disk_cache
    :   Save cache files to disk (.blend file must be saved first)

        Type:
        :   boolean, default False

    use_external
    :   Read cache from an external location

        Type:
        :   boolean, default False

    use_library_path
    :   Use this file’s path for the disk cache when library linked into another file (for local bakes per scene file, disable this option)

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # BrightContrastModifier(StripModifier)

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

*class* bpy.types.BrightContrastModifier(*StripModifier*)
:   Bright/contrast modifier data for sequence strip

    bright
    :   Adjust the luminosity of the colors

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

    contrast
    :   Adjust the difference in luminosity between pixels

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

    open_mask_input_panel
    :   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: Explain Properties in complete detail according to the official Blender documentation.

assistant: Distribution Method
:   The method used to scatter points inside the grid volume:

    Random:
    :   Distribute points randomly inside the grid, weighted by voxel density.
        Produces a natural, stochastic scattering pattern.

    Grid:
    :   Distribute points evenly in a regular grid pattern inside the volume.
        The spacing between points is controlled by the *Spacing* input.
user: Give a detailed overview of Quantize: syntax, arguments, return values, common patterns.

assistant: This operator uses a process known as [Quantization](https://en.wikipedia.org/wiki/Quantization)
which takes the input weights and clamps each weight to a number of steps between (0 - 1),
so there is no longer a smooth gradient between values.

[image reference removed]

Quantize example (Steps = 2).

Steps
:   The number of steps between 0 and 1 to quantize the weights into.
    For example 5 would allow the following weights `[0.0, 0.2, 0.4, 0.6, 0.8, 1.0]`.
user: Explain Life Time in complete detail according to the official Blender documentation.

assistant: Every data-block has its usage counted (reference count), when there is more than one,
you can see the number of current users of a data-block to the right of its name in the interface.
Blender follows the general rule that unused data is eventually removed.

Since it is common to add and remove a lot of data while working,
this has the advantage of not having to manually manage every single data-block.
This works by skipping zero user data-blocks when writing blend-files.

### Protected

Since zero user data-blocks are not saved,
there are times when you want to force the data to be kept irrespective of its users.

If you are building a blend-file to serve as a library of assets that you intend to link to and from other files,
you will need to make sure that they do not accidentally get deleted from the library file.

To protect a data-block, use the button with the shield icon next to its name.
The data-block will then never be silently deleted by Blender,
but you can still manually remove it if needed.
user: Provide the full official documentation entry for What is an Asset?, preserving all code examples.

assistant: **An asset is a data-block with meaning**.

A blend-file is a database with multiple [Data-Blocks](../data_blocks.html): objects, textures, materials,
etc. When planning to re-use or share these, the data needs a meaning. What is this? What is this for?
**Assets are curated data-blocks that are meant for easy reuse**.
user: How do I use Dependency graph: bpy.data.meshes.new_from_object() in Blender? Include parameters, examples, warnings and best practices.

assistant: Function to copy a new mesh from any object with geometry. The mesh is added to the main
database and can be referenced by objects. Typically used by tools that create new objects
or apply modifiers.

When is used on original object, the result mesh is calculated from the object without taking
animation or modifiers into account:

- For meshes this is similar to duplicating the source mesh.
- For curves this disables own modifiers, and modifiers of objects used as bevel and taper.
- For meta-balls this produces an empty mesh since polygonization is done as a modifier evaluation.

When is used on evaluated object all modifiers are taken into account.

All the references (such as materials) are re-mapped to original. This ensures validity and
consistency of the main database.

```
import bpy

class OBJECT_OT_mesh_from_object(bpy.types.Operator):
    """Convert selected object to mesh and show number of vertices"""
    bl_label = "DEG Mesh From Object"
    bl_idname = "object.mesh_from_object"

    def execute(self, context):
        # Access input original object.
        obj = context.object
        if obj is None:
            self.report({'INFO'}, "No active mesh object to convert to mesh")
            return {'CANCELLED'}
        # Avoid annoying None checks later on.
        if obj.type not in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META'}:
            self.report({'INFO'}, "Object cannot be converted to mesh")
            return {'CANCELLED'}
        depsgraph = context.evaluated_depsgraph_get()
        object_eval = obj.evaluated_get(depsgraph)
        mesh_from_eval = bpy.data.meshes.new_from_object(object_eval)
        self.report({'INFO'}, f"{len(mesh_from_eval.vertices)} in new mesh, and is ready for use!")
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_mesh_from_object)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_mesh_from_object)

if __name__ == "__main__":
    register()
```
user: Show practical ways to work with Alpha Over Node in a Blender add-on or script – include code.

assistant: # Alpha Over Node

[image reference removed]

The *Alpha Over* node composites two images by layering the *Foreground* image over the *Background*,
using standard alpha blending operations.

This node is commonly used to combine rendered elements, overlays, or visual effects in a single image,
such as placing text, logos, or transparent effects over footage.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: [image reference removed]

The difference between *F1* and *Smooth F1* can be used to create beveled Voronoi cells.

[image reference removed]

Creating a hammered metal shader using the *Voronoi Texture* node.
user: Explain Viewport Display in complete detail according to the official Blender documentation.

assistant: # Viewport Display

This panel lets you customize the look of your bones.

[image reference removed]

Viewport Display panel in Object/Pose mode.

[image reference removed]

Viewport Display panel in Edit mode.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Type
:   *Bands* or *Rings* shaped waves.

Bands/Rings Direction
:   The axis the bands or rings propagate from i.e. which axis they are perpendicular to.
    When using *Bands* a *Diagonal* axis is an option and when using *Rings* the rings
    can propagate outwards from a single point by using *Spherical* direction.

Wave Profile
:   Controls the look of the wave type.

    Saw:
    :   Uses a sawtooth profile.

    Sine:
    :   Uses the standard sine profile.
user: What is TextureNodeTexMarble(TextureNode) and how is it used in Blender Python scripting?

assistant: # TextureNodeTexMarble(TextureNode)

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

*class* bpy.types.TextureNodeTexMarble(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Is Edge Boundary Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Is Edge Boundary Node

[image reference removed]

The *Is Edge Boundary* node outputs a boolean value indicating
whether each edge lies on the boundary of a mesh.
Boundary edges are edges connected to only one face,
typically located at the open borders of a mesh.

This node is useful for identifying open edges, detecting holes,
or creating effects that depend on mesh boundaries.
user: Show practical ways to work with Dpaint Operators in a Blender add-on or script – include code.

assistant: # Dpaint Operators

bpy.ops.dpaint.bake()
:   Bake dynamic paint image sequence surface

bpy.ops.dpaint.output_toggle(*\**, *output='A'*)
:   Add or remove Dynamic Paint output data layer

    Parameters:
    :   **output** (enum in [`'A'`, `'B'`], (optional)) – Output Toggle

bpy.ops.dpaint.surface_slot_add()
:   Add a new Dynamic Paint surface slot

bpy.ops.dpaint.surface_slot_remove()
:   Remove the selected surface slot

bpy.ops.dpaint.type_toggle(*\**, *type='CANVAS'*)
:   Toggle whether given type is active or not

    Parameters:
    :   **type** (enum in [Prop Dynamicpaint Type Items](bpy_types_enum_items/prop_dynamicpaint_type_items.html#rna-enum-prop-dynamicpaint-type-items), (optional)) – Type
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`PropertyGroup.name`](bpy.types.PropertyGroup.html#bpy.types.PropertyGroup.name "bpy.types.PropertyGroup.name") |
user: Explain Header in complete detail according to the official Blender documentation.

assistant: A header is a small horizontal strip, which sits either at the top or bottom of an area.
All editors have a header acting as a container for menus and commonly used tools.
[Menus](../controls/buttons/menus.xhtml#bpy-types-uipopupmenu) and buttons will change with the editor type and
the selected object and mode.

[image reference removed]

The Header of the 3D Viewport.

### Context Menu

`RMB` on a header reveals a context menu with a couple options:

Show Header
:   Toggles the visibility of the header.
    If a header is hidden, it can be made visible again by clicking or dragging
    the small arrow that appears at the top/bottom right of the editor.

Show Tool Settings
:   Toggles the visibility of the [Tool Settings](#tool-settings).

Show Menus
:   Toggles whether the [Menus](../controls/buttons/menus.xhtml#bpy-types-uipopupmenu) are collapsed or not.

Flip to Bottom/Top
:   Toggles whether the header or Tool Settings appear on the top or bottom of the editor.

Vertical/Horizontal Split
:   Shows an indicator line that lets you select the area and position where to split.
    `Tab` switches between vertical/horizontal.

Maximize Area / Focus Mode
:   See [Maximize Area](areas.xhtml#bpy-ops-screen-screen-full-area).

Duplicate Area into New Window
:   See [Duplicate Area into New Window](areas.xhtml#bpy-ops-screen-area-dupli).

Close Area
:   Closes the area and replaces it with the expansion of a neighboring area.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Lattice properties.

Lattice
:   A [Data-Block Menu](../interface/controls/templates/data_block.xhtml#ui-data-block).

### Lattice

Points
:   Rate of subdivision in the axes:

    U, V, W

Interpolation Type
:   Selector for each axis. See [Different types of interpolation.](shape_keys/shape_keys_panel.xhtml#fig-interpolation-type).

    Linear, Cardinal, Catmull-Rom, B-Spline

Outside
:   Takes only the vertices on the surface of the lattice into account.

Vertex Group
:   The strength of the influence assigned as a weight to the individual vertices in the selected vertex group.
user: How do I use VIEW3D_AST_pose_library(AssetShelf) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VIEW3D_AST_pose_library(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_pose_library(*AssetShelf*)
:   *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 Cloth from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cloth

This brush simulates cloth physics on the mesh under the brush cursor.
There are various deformation types and settings to customize the brush.

It’s also easy to sculpt the mesh with other brushes and tools
in between using the cloth brushes.
user: Give a detailed overview of MeshEdge(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MeshEdge(bpy_struct)

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

*class* bpy.types.MeshEdge(*bpy_struct*)
:   Edge in a Mesh data-block

    hide
    :   Type:
        :   boolean, default False

    index
    :   Index of this edge

        Type:
        :   int in [0, inf], default 0, (readonly)

    is_loose
    :   Edge is not connected to any faces

        Type:
        :   boolean, default False, (readonly)

    select
    :   Type:
        :   boolean, default False

    use_edge_sharp
    :   Sharp edge for shading

        Type:
        :   boolean, default False

    use_seam
    :   Seam edge for UV unwrapping

        Type:
        :   boolean, default False

    vertices
    :   Vertex indices

        Type:
        :   int array of 2 items in [0, inf], default (0, 0)

    key
    :   (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Cloth Filter

This tool works similar to the [Cloth Brush](../brushes/cloth.html),
however, it applies a cloth simulation to all vertices in the mesh at the same time.
Click and drag away from the object for a positive effect and towards for a negative effect.
user: Show practical ways to work with Menu Switch Node in a Blender add-on or script – include code.

assistant: # Menu Switch Node

[image reference removed]

The *Menu Switch* node outputs one of its inputs based on a selected menu item.
Only the active input is evaluated, allowing efficient switching between multiple options.

The available menu entries are defined by the user. Menu items can be
added and removed, as well as renamed and reordered in the editor side
bar. Renaming a menu entry keeps existing links of the matching input
socket.

The menu can be used in node groups and the nodes modifier UI.
Connecting the menu input with a *Group Input* node will expose the menu
as a group input. A menu socket in a node group, reroute node, or other
pass-through nodes needs to be connected to a *Menu Switch* node in
order to work. An unconnected menu socket will show an empty menu by
default.

Connecting multiple *Menu Switch* nodes to the same output
socket creates a conflict (even when the menu entries are the same).
To avoid this a menu switch can be wrapped in a node group. Multiple
node groups of the same type can be connected to the same menu, since
they contain the same menu switch node.

|  |  |
| --- | --- |
| ../../../_images/node-types_GeometryNodeMenuSwitch_conflict.webp   Conflict caused by connecting different menus. | ../../../_images/node-types_GeometryNodeMenuSwitch_group_wrapper.webp   Same node group can be connected without conflict. |
user: Explain Miscellaneous in complete detail according to the official Blender documentation.

assistant: Sculpt Overlay Color
:   Defines a color to be used in the inner part of
    the brushes circle when in Sculpt Mode, and it is placed as an overlay to the brush,
    representing the focal point of the brush influence.
    The overlay color is visible only when the overlay visibility is selected
    (clicking at the *eye* to set its visibility), and the transparency of the overlay is
    controlled by the alpha slider located at the Tool tab ‣ Display panel in the Sidebar.
user: Describe Quad View from the Blender manual or Python API, including usage steps and snippets.

assistant: Toggling Quad View will split the 3D Viewport into four views:
three orthographic side views and one user perspective view.

[image reference removed]

Quad View.

### Options

Lock Rotation
:   Prevent changes to the orientation and perspective of the 3D Viewport.

Sync Zoom/Pan
:   Syncs the view position between side views. (Requires *Lock Rotation* to be enabled.)

Clip Contents
:   Clip objects based on what is visible in the other side views.
user: Provide the full official documentation entry for Curve Display, preserving all code examples.

assistant: # Curve Display

When in Edit Mode, curves have special [overlays](../../editors/3dview/display/overlays.xhtml)
to control how curves are displayed in the 3D Viewport.

Handles
:   Controls the visibility of Bézier curve handles in edit mode.

    None:
    :   Hides all Bézier curve handles, providing an unobstructed view of the curve.

    Selected:
    :   Displays the handles only for selected control points.

    All:
    :   Displays the handles for all control points in the curve.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Mode
:   Points:
    :   The position and radius of the circle are determined by three points.
        The center of the circle is also given as an output.
        If the three points lie on one line, no geometry is generated.

    Radius:
    :   The circle is determined by the radius.
user: Explain LineStyleColorModifiers(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # LineStyleColorModifiers(bpy_struct)

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

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

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

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

        Returns:
        :   Newly added color modifier

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Shrinkwrap Modifier

The *Shrinkwrap* modifier allows an object to “shrink” to the surface of another object.
It moves each vertex of the object being modified to the closest position on
the surface of the given mesh (using one of the four methods available).

It can be applied to meshes, lattices, curves, surfaces and texts.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: Here is an example of various effects achieved using *Vertex Weight Edit* modifier
(together with the [Vertex Weight Proximity](weight_proximity.xhtml) modifier)
to generate weights used by the [Displace](../deform/displace.xhtml) modifier.

*Curve Map* variations.

|  |
| --- |
| ../../../_images/modeling_modifiers_modify_weight-edit_mapping-concave.jpg   Concave-type mapping curve. |
| ../../../_images/modeling_modifiers_modify_weight-edit_distance-edge.jpg   No mapping curve (linear). |
| ../../../_images/modeling_modifiers_modify_weight-edit_mapping-convex.jpg   Convex-type mapping curve. |

[image reference removed]

Vertices with a computed weight below 0.1 removed from the vertex group.

[The blend-file](https://archive.blender.org/wiki/2015/index.php/File:ManModifiersWeightVGroupEx.blend),
TEST_2 scene.
user: Explain Relax in complete detail according to the official Blender documentation.

assistant: # Relax

The Relax tool can be used to distribute UVs more evenly.
It works by pulling vertices along UV edges to bring the UV unwrap into balance.

The Relax tool can be compared with the [Minimize Stretch](../editing.html#bpy-ops-uv-minimize-stretch) tool which works directly
on faces to reduce texture stretching and shearing.
You may find that sometimes minimize stretch works better, sometimes the unwrap
tool and other times the Relax tool.

First using Unwrap, then Minimize Stretch and touching up with the Relax tool often gives the best results.
Remember, you can use “Undo” at any time to return to an earlier state.
user: What is Attributes and how is it used in Blender Python scripting?

assistant: Geometry attributes can be read through the `getattribute()` function.
This includes UV maps, color attributes and any attributes output from geometry nodes.

The following built-in attributes are available through `getattribute()` as well.

`geom:generated`
:   Automatically generated texture coordinates, from non-deformed mesh.

`geom:uv`
:   Default render UV map.

`geom:tangent`
:   Default tangent vector along surface, in object space.

`geom:undisplaced`
:   Position before displacement, in object space.

`geom:dupli_generated`
:   For instances, generated coordinate from instancer object.

`geom:dupli_uv`
:   For instances, UV coordinate from instancer object.

`geom:trianglevertices`
:   Three vertex coordinates of the triangle.

`geom:numpolyvertices`
:   Number of vertices in the polygon (always returns three currently).

`geom:polyvertices`
:   Vertex coordinates array of the polygon (always three vertices currently).

`geom:name`
:   Name of the object.

`geom:is_smooth`
:   Is mesh face smooth or flat shaded.

`geom:is_curve`
:   Is object a curve or not.

`geom:curve_intercept`
:   0..1 coordinate for point along the curve, from root to tip.

`geom:curve_thickness`
:   Thickness of the curve in object space.

`geom:curve_length`
:   Length of the curve in object space.

`geom:curve_tangent_normal`
:   Tangent Normal of the strand.

`geom:is_point`
:   Is point in a point cloud or not.

`geom:point_radius`
:   Radius of point in point cloud.

`geom:point_position`
:   Center position of point in point cloud.

`geom:point_random`
:   Random number, different for every point in point cloud.

`path:ray_length`
:   Ray distance since last hit.

`object:random`
:   Random number, different for every object instance.

`object:index`
:   Object unique instance index.

`object:location`
:   Object location.

`material:index`
:   Material unique index number.

`particle:index`
:   Particle unique instance number.

`particle:age`
:   Particle age in frames.

`particle:lifetime`
:   Total lifespan of particle in frames.

`particle:location`
:   Location of the particle.

`particle:size`
:   Size of the particle.

`particle:velocity`
:   Velocity of the particle.

`particle:angular_velocity`
:   Angular velocity of the particle.
user: What is Rim Visual Effect and how is it used in Blender Python scripting?

assistant: # Rim Visual Effect

The *Rim* Visual Effect shows a simulated rim light on the object contour.

For simulating the rim light, a masked color silhouette of the object is
displaced in horizontal and/or vertical direction.

Many blending modes can be applied to the resulting mask.
user: Give a detailed overview of Notes: syntax, arguments, return values, common patterns.

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](../../../render/shader_nodes/textures/white_noise.xhtml#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: ### Selecting a Brush, Color & Mode

In the Tool Settings select the brush, color and mode to use with the tool.

You can configure the brush main settings included in the Tool Settings for convenience.
For the vertex paint brushes configuration and settings see
[Vertex Paint Brush](../../vertex_paint/tool_settings/brush.xhtml).

`Ctrl`-`LMB` erase the Color Attribute.

### Painting

Click and hold `LMB` or use the pen tip to paint onto the stroke points.

Vertex painting stroke points.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_tint_paint-01.png | ../../../../_images/grease-pencil_modes_draw_tools_tint_paint-02.png | ../../../../_images/grease-pencil_modes_draw_tools_tint_paint-03.png |
user: Show practical ways to work with Preview in a Blender add-on or script – include code.

assistant: To view your changes, build the manual [as instructed](build.xhtml).
Keep in mind that you can also build only the chapter you just edited to view it quickly.
Open the generated `.html` files inside the `build/html` folder using your web browser,
or refresh the page if you have it open already.
user: Provide the full official documentation entry for Thickness, preserving all code examples.

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

Minimum/Maximum
:   Minimum/Maximum thickness to display.

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

[[image reference removed]](../../_images/modeling_meshes_mesh-analysis_thickness.png)

Thickness.
user: What is Menus and how is it used in Blender Python scripting?

assistant: Close Menu on Leave
:   Close menus when the mouse is moved out of the region.

### Open on Mouse Over

Select this to have the menu open by placing the mouse pointer over the entry instead of clicking on it.

Top Level
:   Time delay in 1/10 second before a menu opens (*Open on Mouse Over* needs to be enabled).

Sub Level
:   Same as above for sub menus (for example: File ‣ Open Recent).

### Pie Menus

Animation Timeout
:   Length of animation when opening Pie Menus.

Tap Key Timeout
:   Keystrokes held longer than this will dismiss the menu on release (in 1/100ths of a second).

Recenter Timeout
:   The window system tries to keep the pie menu within the window borders.
    Pie menus will use the initial mouse position as center for this amount of time, measured in 1/100ths of a second.
    This allows for fast dragged selections.

Radius
:   The size of the Pie Menu set with the distance (in pixels) of the menu items from the center of the pie menu.

Threshold
:   Distance from center before a selection can be made.

Confirm Threshold
:   Distance threshold after which selection is made (zero disables).
user: Describe Final Render from the Blender manual or Python API, including usage steps and snippets.

assistant: Persistent Data
:   Keep render data in memory after rendering for faster re-renders and animation renders
    at the cost of extra memory usage while performing other tasks in Blender.

    When using multiple [View Layers](../../layers/view_layer.html),
    only data from a single view layer is preserved to keep memory usage within bounds;
    however, objects shared between view layers are preserved.
user: Explain BlendDataSounds(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BlendDataSounds(bpy_struct)

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

*class* bpy.types.BlendDataSounds(*bpy_struct*)
:   Collection of sounds

    load(*filepath*, *\**, *check_existing=False*)
    :   Add a new sound to the main database from a file

        Parameters:
        :   - **filepath** (string, (never None, blend relative `//` prefix supported)) – path for the data-block
            - **check_existing** (*boolean**,* *(**optional**)*) – Using existing data-block if this file is already loaded

        Returns:
        :   New text data-block

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

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

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

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

assistant: Type
:   Specifies the input/output type.

    Vector, Point, Normal.

Convert From
:   Coordinate Space to convert from:

    World, Object, Camera.

Convert To
:   Coordinate Space to convert to:

    World, Object, Camera.
user: Show practical ways to work with The Weighting Color Code in a Blender add-on or script – include code.

assistant: Weights are visualized by a gradient using a cold/hot color system,
such that areas of low value (with weights close to 0.0) are displayed as blue (cold)
and areas of high value (with weights close to 1.0) are displayed as red (hot).
And all in-between values are displayed as rainbow colors (blue, green, yellow, orange, red).

[image reference removed]

The color spectrum and their respective weights.

In addition to the above described color code, Blender has a special visual notation
(as an option) for unreferenced vertices: They are displayed as black.
Thus you can see the referenced areas (displayed as cold/hot colors) and
the unreferenced areas (in black) at the same time.
This is most useful when you look for weighting errors.
See [Viewport Overlays](../../editors/3dview/display/overlays.xhtml#dview-overlay-weight-paint).

[image reference removed]

Unreferenced vertices example.