PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Is Edge Loose Node in complete detail according to the official Blender documentation.

assistant: # Is Edge Loose Node

[image reference removed]

The *Is Edge Loose* node outputs a boolean value indicating whether each edge in a mesh
is *loose*. A loose edge is not connected to any faces, meaning it exists independently
of the mesh surface.

This node can be used to detect or isolate wireframe elements, stray geometry, or edges
intentionally used for guides or supports.
user: How do I use NodeTreeInterfaceSocketBundle(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketBundle(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.NodeTreeInterfaceSocketBundle(*NodeTreeInterfaceSocket*)
:   Bundle socket of a node

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

assistant: # Introduction

The UV Editor is used for editing UV maps, which describe how a 2D image should be mapped
onto a 3D object.

[image reference removed]

UV Editor with a UV map and a test grid texture.

Image textures are typically needed when the desired look is hard to achieve with procedural textures,
or if the texture is not uniform. For example, a car would only have scratches in a few places where they make sense,
not in random places all over its body.

Blender offers a number of projections (Box, Sphere…) that automatically apply a 2D image to a 3D object,
but these tend to only work for simple meshes. For more complex ones, you need to create a UV map instead.
This is a flat area where each face of the 3D object is laid out on the 2D image, specifying which part of the
image it should be textured with. This gives you complete control over the mapping process.

The name “UV” refers to the axes of the map: U for horizontal, V for vertical. These letters were chosen to
avoid confusion with “X” and “Y”, which refer to axes in 3D space instead.
user: How do I use Cloth with Animated Vertex Groups in Blender? Include parameters, examples, warnings and best practices.

assistant: Cloth with animated pinned vertices:
[Regression blend-file](https://archive.blender.org/wiki/2015/index.php/File:Cloth_anim_vertex.blend).
Unsupported: Starting with a goal of 0 and increasing it,
but still having the vertex not pinned will **not** work (e.g. from goal = 0 to goal = 0.5).
user: Explain Interactive Region in complete detail according to the official Blender documentation.

assistant: The interactive region is the bottom half of the splash screen.

New File
:   Start a new project based on a template.

Recent Files
:   Your most recently opened blend-files. This gives quick and easy access to your recent projects.

Open
:   Allows opening an existing blend-file.

Recover Last Session
:   Blender will try to recover the last [session](../../glossary/index.xhtml#term-Session) based on temporary files. See
    [Recovering Data](../../troubleshooting/recover.xhtml).

What’s New
:   Open the latest release notes.

Donate to Blender
:   Open Blender’s [Development Fund](https://fund.blender.org/) website.
user: Describe Screw from the Blender manual or Python API, including usage steps and snippets.

assistant: # Screw

The *Screw* operator extrudes geometry along a helix. You can use it to create screws, springs,
sea shells and so on.

While it’s similar to the [Screw Modifier](../../../modifiers/generate/screw.xhtml),
there are some important differences:

| Screw operator | Screw modifier |
| --- | --- |
| Works in world space. | Works in object space. |
| Extrudes only the selected geometry. | Extrudes all geometry. |
| The centerpoint can be specified manually. | The centerpoint is always the object’s origin. |
| One revolution is always 360°. | The angle can be chosen freely. |
| The height offset of each revolution is calculated automatically based on the geometry. | The height offset must be specified manually. |
| Each revolution can also have a radial offset away from/towards the central axis (again determined by the geometry). | The radius stays constant. |

As described above, the Screw operator automatically determines the height offset and radial
offset to apply after each revolution. It does this by looking for the endpoints of an open profile –
a series of connected edges that don’t form a closed loop. The geometry is extruded so that the
profile’s top vertex in one revolution will coincide with the bottom vertex in the next.

The most common use case is extruding such an open profile. You’re not limited to this, however.
As long as there is one open profile in the selection – even just a single loose edge –
you can also extrude closed profiles and even geometry with faces.

You can see some examples below.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_screw_example-shell.png   Wood Screw. | ../../../../_images/modeling_meshes_editing_edge_screw_example-spring.png   Spring. |
user: Explain Install from a DMG in complete detail according to the official Blender documentation.

assistant: Blender for macOS is distributed as disk images (dmg-files). To mount the disk image, double-click on the dmg-file.
Then drag `Blender.app` into the Applications folder.

Depending on the Security and Privacy preferences of your Mac, macOS will request your approval before opening Blender
for the first time.

To make the installation and configuration fully self-contained, set up a
[Portable Installation](../../advanced/blender_directory_layout.xhtml#portable-installation).
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: ### Keyframe Animation

This example shows you how to animate a cube’s location, rotation, and scale.

1. First, in the Timeline, or other animation editors, set the frame to 1.
2. With the cube selected in Object Mode, press `I` in the 3D Viewport.
   This will record the location, rotation, and scale, for the cube on frame 1.
3. Set the frame to 100.
4. Use Move `G`, Rotate `R`, Scale `S`, to transform the cube.
5. Press `I` in the 3D Viewport.

To test the animation, press `Spacebar` to play.

[[image reference removed]](../../_images/animation_keyframes_editing_keyframe-animation-examples.png)

The animation on frames 1, 50 and 100.
user: Show practical ways to work with Position Node in a Blender add-on or script – include code.

assistant: # Position Node

[image reference removed]

The *Position* node outputs a vector of each point of the geometry the node is connected to.

The node can work on geometry domains besides points. In that case, the position data will be
automatically interpolated to the new domain. For example, when used as part of the input to
the [Split Edges Node](../../mesh/operations/split_edges.xhtml), the position for each edge
will be the average position of the edge’s two vertices.

For instances themselves, the output is the origin of each instance. However, if the node is for
a geometry node that adjusts data inside instances, the position output of this node will be
in the local space of each instance. See the [Instance Processing](../../instances.xhtml#geometry-nodes-instance-processing) page
for more details.
user: What is Troubleshooting Linux – AMD and how is it used in Blender Python scripting?

assistant: # Troubleshooting Linux – AMD

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: How do I use Snap in Blender? Include parameters, examples, warnings and best practices.

assistant: [Mesh snapping](../../../editors/3dview/controls/snapping.xhtml) also works with curve components.
Both control points and their handles will be affected by snapping,
except for within itself (other components of the active curve).
Snapping works with 2D curves but points will be constrained to the local XY axes.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Type
:   The direction of convert alpha.
    For details on the difference between both ways to store alpha values see [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel).

    To Premultiplied:
    :   Converts from [Straight Alpha](../../../glossary/index.xhtml#term-Straight-Alpha) to [Premultiplied Alpha](../../../glossary/index.xhtml#term-Premultiplied-Alpha).

    To Straight:
    :   Converts from [Premultiplied Alpha](../../../glossary/index.xhtml#term-Premultiplied-Alpha) to [Straight Alpha](../../../glossary/index.xhtml#term-Straight-Alpha).
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") - [`BoidRule.name`](bpy.types.BoidRule.html#bpy.types.BoidRule.name "bpy.types.BoidRule.name") - [`BoidRule.type`](bpy.types.BoidRule.html#bpy.types.BoidRule.type "bpy.types.BoidRule.type") | - [`BoidRule.use_in_air`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_in_air "bpy.types.BoidRule.use_in_air") - [`BoidRule.use_on_land`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_on_land "bpy.types.BoidRule.use_on_land") |
user: How do I use Enabling Add-on in Blender? Include parameters, examples, warnings and best practices.

assistant: 1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “Node Wrangler” and check the *Enable Add-on* checkbox.
user: Explain View in complete detail according to the official Blender documentation.

assistant: ### Backdrop

[image reference removed]

Backdrop panel.

The backdrop is the output of a Viewer node in the background of the Compositor.
For example, when `Shift`-`Ctrl`-`LMB` on an Image node, it displays a preview of the image,
or on a Mix node, will show the result of the mixing.
You can toggle the backdrop by clicking the checkbox in the *Backdrop* panel title
or by clicking on the *Backdrop* button in the header.

Channels
:   The color channels to display of the backdrop image.

Zoom `Alt`-`V` `V`
:   Sets the size of the backdrop image.

Offset
:   Change the screen space position of the backdrop.

Move `Alt`-`MMB`
:   Changes the position of the backdrop.

Fit
:   Scales the backdrop to fit the size of the Compositor.

Reset Backdrop
:   Sets back to the default values of Zoom to 1 and Offset to 0.
user: Give a detailed overview of UV Sphere: syntax, arguments, return values, common patterns.

assistant: A UV sphere is composed of quad faces arranged in horizontal rings and vertical segments,
with triangle fans at the poles. This structure mirrors how textures are typically mapped
in 2D (hence the name “UV” sphere), making it well-suited for texturing.

It resembles lines of latitude and longitude on a globe, which also makes it useful for
planetary models or spherical shapes with pole-to-pole UV seams.

Segments
:   Number of vertical segments (longitudinal divisions).
    These are like meridians on a globe, running from the north to south pole.

Rings
:   Number of horizontal segments (latitudinal divisions).
    These are like parallels on a globe, stacked from top to bottom.

Radius
:   Distance from the center to the outer surface of the sphere.
user: Show practical ways to work with Brush Settings in a Blender add-on or script – include code.

assistant: Direction
:   Determines whether to grow or shrink the curves. It can be toggled holding `Ctrl` while sculpting.

Scale Uniform
:   Grow or shrink curves by changing their size uniformly instead of using trimming or extrapolation.

Minimum Length
:   Avoid shrinking curves shorter than this length.
user: Describe Particle Instance Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Particle Instance Modifier

When a Particle Instance modifier is added to an object,
the mesh of this object will be duplicated
at the location of the particles of the selected particle system from another target object.
This means that to use this modifier, you must have at least one other object
that has a [Particles System](../../../physics/particles/index.html) on it.

Because of the correlation in which the Particle Instance modifier is
influenced by the underlying particle systems on other objects, some of the apparent effects
generated by the modifier can look and act vastly different,
depending on the underlying settings of the particle systems it is associated with.
This is worth taking account of, when it seems that the Particle Instance modifier settings
do not return the expected results.
user: Give a detailed overview of Lock/Mute: syntax, arguments, return values, common patterns.

assistant: Lock Strips `Ctrl`-`H`
:   Disables the strip from being transformed.

Unlock Strips `Ctrl`-`Alt`-`H`
:   Enables disabled strips allowing them to be transformed.

Mute/Unmute Strips `H`, `Alt`-`H`
:   Mute or unmute the selected strips.

Mute/Unmute Deselected Strips `Shift`-`H`, `Shift`-`Alt`-`H`
:   Mute or unmute all strips but the selected.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`BlendData.cache_files`](bpy.types.BlendData.html#bpy.types.BlendData.cache_files "bpy.types.BlendData.cache_files") - [`MeshSequenceCacheModifier.cache_file`](bpy.types.MeshSequenceCacheModifier.html#bpy.types.MeshSequenceCacheModifier.cache_file "bpy.types.MeshSequenceCacheModifier.cache_file") | - [`TransformCacheConstraint.cache_file`](bpy.types.TransformCacheConstraint.html#bpy.types.TransformCacheConstraint.cache_file "bpy.types.TransformCacheConstraint.cache_file") |
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Combined with the [Geometry to Instance Node](../geometry_to_instance.html),
this can be used to create a basic efficient “Array” operation. This should be more efficient
because the duplicates are [instances](../../instances.html).

The “Duplicate Index” is used to move each instance in the result a different amount.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`FreestyleLineStyle.alpha_modifiers`](bpy.types.FreestyleLineStyle.html#bpy.types.FreestyleLineStyle.alpha_modifiers "bpy.types.FreestyleLineStyle.alpha_modifiers") - [`LineStyleAlphaModifiers.new`](bpy.types.LineStyleAlphaModifiers.html#bpy.types.LineStyleAlphaModifiers.new "bpy.types.LineStyleAlphaModifiers.new") | - [`LineStyleAlphaModifiers.remove`](bpy.types.LineStyleAlphaModifiers.html#bpy.types.LineStyleAlphaModifiers.remove "bpy.types.LineStyleAlphaModifiers.remove") |
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   The input geometry containing the hair curves to deform.

Cumulative Offset
:   When enabled, each point’s offset is influenced by the displacement of the preceding points
    along the curve.
    This produces smoother and more continuous bending rather than independent point motion.

Factor
:   Controls the overall intensity of the noise deformation.
    A value of 0.0 disables the effect, while 1.0 applies the full displacement.

Distance
:   Multiplies the amplitude of the noise displacement.
    Higher values increase how far the hair is moved from its original shape.

Shape
:   Defines the variation of the effect along the curve length.
    A value of 0.0 applies a constant deformation, while 0.5 produces a linear falloff from root to tip.

Scale
:   Adjusts the scale of the noise texture based on the root position of each curve.
    Smaller values create larger, smoother waves, while higher values produce finer detail.

Scale along Curve
:   Defines the frequency of the noise along each individual curve.
    Higher values create tighter, more frequent variations along the hair strands.

Offset per Curve
:   Adds a random offset to the noise pattern for each curve.
    This ensures that each hair receives a unique noise variation.

Seed
:   Sets the random seed used to initialize the noise pattern.
    Changing this value produces different random results while maintaining the same parameters.

Preserve Length
:   When enabled, maintains the original length of each curve segment during deformation.
    When disabled, noise deformation may stretch or compress the curve slightly.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: SDF Grid
:   A float grid representing the signed distance field of the mesh.
    Each voxel contains the shortest signed distance to the nearest surface
    point of the mesh, with negative values inside and positive values outside.
user: Describe Methods from the Blender manual or Python API, including usage steps and snippets.

assistant: The following methods are used automatically depending on the context.

### Isolated Vertices

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_verts-simple-before.png>   Before. | <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_verts-simple-after.png>   After. |

### Isolated Edges

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_edge-simple-before.png>   Before. | <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_edge-simple-after.png>   After. |

### N-gon from Edges

When there are many edges Blender will make an n-gon.
Note that, this does not support holes,
to support holes you need to use the [Fill](../face/fill.html#modeling-meshes-editing-fill) Faces tool.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_ngon-before.png>   Before. | <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_ngon-after.png>   After. |

### Mixed Vertices/Edges

Existing edges are used to make the face as well as an extra vertex.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_mix-simple-before.png>   Before. | <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_mix-simple-after.png>   After. |

### Edge-Net

Sometimes you may have many connected edges without interior faces.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_net-before.png>   Before. | <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_net-after.png>   After. |

### Point Cloud

When there are many isolated vertices,
Blender will calculate the edges for an n-gon.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_cloud-before.png>   Before. | <../../../../_images/modeling_meshes_editing_vertex_make-face-edge_cloud-after.png>   After. |

### Single Vertex Selection

With a single vertex selected on a boundary,
the face will be created along the boundary,
this saves manually selecting the other two vertices.
Notice this tool can run multiple times to continue creating faces.

[image reference removed]

### Dissolve Existing Faces

When you have a region of existing faces, creating a face on this selection
will remove the shared vertices and edges, creating a single face.

This is simply a convenience for accessing [Dissolve Faces](../mesh/delete.html#bpy-ops-mesh-dissolve-faces).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Count
:   Number of vertices on the line.

Resolution
:   Length of individual edges.
    The node tries to fit as many vertices as possible between the start and end point.
    The exact end point might not be hit.
    This is only available when the mode is set to *End Points* and the count mode is set to *Resolution*.

Start Location
:   Position of the first vertex.

Offset
:   Controls the direction of the line and distance between the vertices.
    This is only available when the mode is set to *Offset*.

End Location
:   Position of the last vertex.
    This is only available when the mode is set to *End Points*.
user: Describe Modifiers from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Common Options

Mix
:   The modifier output can be mixed with the base property using the usual methods
    (see for example the [Mix compositing node](../../../../compositing/types/color/mix_color.xhtml)).

Influence
:   How much the result of this modifier affects the current property.

Mapping
:   Either a linear progression (from 0.0 to 1.0),
    or a custom mapping [curve](../../../../interface/controls/templates/curve.xhtml#ui-curve-widget).

Invert
:   Inverts the *Mapping*.

### Types

- [Along Stroke](modifiers/alpha/along_stroke.xhtml)
- [Crease Angle](modifiers/alpha/crease_angle.xhtml)
- [Curvature 3D](modifiers/alpha/curvature_3d.xhtml)
- [Distance from Camera](modifiers/alpha/distance_from_camera.xhtml)
- [Distance from Object](modifiers/alpha/distance_from_object.xhtml)
- [Material](modifiers/alpha/material.xhtml)
- [Noise](modifiers/alpha/noise.xhtml)
- [Tangent](modifiers/alpha/tangent.xhtml)
user: What is Keeping a Correct State and how is it used in Blender Python scripting?

assistant: When modeling in Blender there are certain assumptions made about the state of the mesh:

- Hidden geometry isn’t selected.
- When an edge is selected, its vertices are selected too.
- When a face is selected, its edges and vertices are selected.
- Duplicate edges / faces don’t exist.
- Faces have at least three vertices.

To give developers flexibility these conventions are not enforced,
yet tools must leave the mesh in a valid state or else other tools may behave incorrectly.
Any errors that arise from not following these conventions is considered a bug in the script,
not a bug in Blender.

### Selection / Flushing

As mentioned above, it is possible to create an invalid selection state
(by selecting a state and then deselecting one of its vertices for example),
mostly the best way to solve this is to flush the selection
after performing a series of edits. This validates the selection state.
user: Give a detailed overview of Contextual Views: syntax, arguments, return values, common patterns.

assistant: # Contextual Views

By default, the 3D Viewport only shows the scene from one viewpoint.
By using Quad Views, you can see it from multiple viewpoints at the same time,
which gives more context about the changes you’re making.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`ShaderNodeTexBrick.color_mapping`](bpy.types.ShaderNodeTexBrick.html#bpy.types.ShaderNodeTexBrick.color_mapping "bpy.types.ShaderNodeTexBrick.color_mapping") - [`ShaderNodeTexChecker.color_mapping`](bpy.types.ShaderNodeTexChecker.html#bpy.types.ShaderNodeTexChecker.color_mapping "bpy.types.ShaderNodeTexChecker.color_mapping") - [`ShaderNodeTexEnvironment.color_mapping`](bpy.types.ShaderNodeTexEnvironment.html#bpy.types.ShaderNodeTexEnvironment.color_mapping "bpy.types.ShaderNodeTexEnvironment.color_mapping") - [`ShaderNodeTexGabor.color_mapping`](bpy.types.ShaderNodeTexGabor.html#bpy.types.ShaderNodeTexGabor.color_mapping "bpy.types.ShaderNodeTexGabor.color_mapping") - [`ShaderNodeTexGradient.color_mapping`](bpy.types.ShaderNodeTexGradient.html#bpy.types.ShaderNodeTexGradient.color_mapping "bpy.types.ShaderNodeTexGradient.color_mapping") - [`ShaderNodeTexImage.color_mapping`](bpy.types.ShaderNodeTexImage.html#bpy.types.ShaderNodeTexImage.color_mapping "bpy.types.ShaderNodeTexImage.color_mapping") | - [`ShaderNodeTexMagic.color_mapping`](bpy.types.ShaderNodeTexMagic.html#bpy.types.ShaderNodeTexMagic.color_mapping "bpy.types.ShaderNodeTexMagic.color_mapping") - [`ShaderNodeTexNoise.color_mapping`](bpy.types.ShaderNodeTexNoise.html#bpy.types.ShaderNodeTexNoise.color_mapping "bpy.types.ShaderNodeTexNoise.color_mapping") - [`ShaderNodeTexSky.color_mapping`](bpy.types.ShaderNodeTexSky.html#bpy.types.ShaderNodeTexSky.color_mapping "bpy.types.ShaderNodeTexSky.color_mapping") - [`ShaderNodeTexVoronoi.color_mapping`](bpy.types.ShaderNodeTexVoronoi.html#bpy.types.ShaderNodeTexVoronoi.color_mapping "bpy.types.ShaderNodeTexVoronoi.color_mapping") - [`ShaderNodeTexWave.color_mapping`](bpy.types.ShaderNodeTexWave.html#bpy.types.ShaderNodeTexWave.color_mapping "bpy.types.ShaderNodeTexWave.color_mapping") |
user: Provide the full official documentation entry for NodeSocketFloatWavelength(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketFloatWavelength(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatWavelength(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (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: How do I use Self-Collisions in Blender? Include parameters, examples, warnings and best practices.

assistant: Real cloth cannot penetrate itself, so you normally want the cloth to self-collide.
Enable this to tell the cloth object that it should not penetrate itself.
This adds to the simulation’s compute time, but provides more realistic results.

Friction
:   A coefficient for how slippery the cloth is when it collides with itself.
    For example, silk has a lower coefficient of friction than cotton.

Distance
:   As cloth at this distance begins to repel away from itself.
    Smaller values might give errors but gives some speed-up while
    larger will give unrealistic results if too large and can be slow.
    It is best to find a good in between value.

Impulse Clamping
:   Prevents explosions in tight and complicated collision situations
    by restricting the amount of movement after a collision.

Vertex Group
:   Faces that have all vertices assigned to this
    [Vertex Group](../../../modeling/meshes/properties/vertex_groups/index.xhtml) are excluded from self-collision.

### Troubleshooting

If you encounter some problems with collision detection, there are a few ways to fix them:

- The fastest solution is to increase the *Distance* for Object/Self Collisions.
  This will be the fastest way to fix the clipping; however, it will be less accurate and will not look as good.
  Using this method tends to make it look like the cloth is resting on air, and gives it a very rounded look.
- A second method is to increase the *Quality* (in the *Cloth* panel).
  This results in smaller steps for the simulator and
  therefore to a higher probability that fast-moving collisions get caught.
  You can also increase the Collisions *Quality* to perform more iterations to get collisions solved.
- If none of the methods help, you can easily edit the cached/baked result in *Edit Mode* afterwards.
- If the Cloth is torn by the deforming mesh; increase the stiffness settings.
user: Provide the full official documentation entry for Bundled Python & Extensions, preserving all code examples.

assistant: The Blender releases distributed from blender.org include a complete Python installation on all platforms,
this has the disadvantage that any extensions you have installed on your system’s Python environment
will not be found by Blender.

There are two ways to work around this:

- Remove Blender Python subdirectory, Blender will then fall back on the system’s Python and use that instead.

  Depending on your platform,
  you may need to explicitly reference the location of your Python installation using
  the `PYTHONPATH` environment variable, e.g:

  ```
  PYTHONPATH=/usr/lib/python3.7 ./blender --python-use-system-env
  ```
- Copy or link the extensions into Blender’s Python subdirectory so Blender can access them,
  you can also copy the entire Python installation into Blender’s subdirectory,
  replacing the one Blender comes with.
  This works as long as the Python versions match and the paths are created in the same relative locations.
  Doing this has the advantage that you can redistribute this bundle to others with Blender
  including any extensions you rely on.
user: Provide the full official documentation entry for Vertex Weights, preserving all code examples.

assistant: # Vertex Weights

[[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_panel-overview.png)

Vertex Weights panel.

A [vertex group](index.html) assigns a weight
(a number between 0 and 1) to each vertex it contains. A group can have multiple vertices,
and each vertex can be part of multiple groups.

The *Vertex Weights* panel in the 3D Viewport’s Sidebar shows the vertex groups for
the active vertex, and lets you see and edit the associated weights.
It’s available in Edit Mode, as well as in Weight Paint Mode when Vertex Selection
is enabled in the header.
user: Give a detailed overview of Select Mode: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Edit Mode selection buttons.

In Edit Mode there are three different selection modes.
You can enter the different modes by selecting one of the three buttons in the header.

Points:
:   To select individual points.

Strokes:
:   To select an entire stroke.

Segments:
:   To select all points that are between other strokes.

[image reference removed]

Points, stroke and in between stroke selection sample.
user: How do I use Mesh Filters in Blender? Include parameters, examples, warnings and best practices.

assistant: Applies a deformation to all vertices in the mesh at the same time.
Masking, auto-masking and visibility will be taken into account.

To use these operators, click and drag away from left to right
or from right to left for a negative effect.

Smooth
:   Smooths the positions of the vertices to either polish surfaces or remove volume from larger shapes.
    Especially useful to fix most of the artifacts of the voxel remesher.
    This filter works similar to the [Smooth](../brushes/smooth.xhtml) brush.

Surface Smooth
:   Eliminates irregularities of the mesh by making the positions
    of the vertices more uniform while preserving the volume of the object.
    This filter works similar to the *Surface* deformation type of the
    [Smooth](../brushes/smooth.xhtml) brush.

Inflate
:   Displaces vertices uniformly along their normal.
    This filter works similar to the [Inflate](../brushes/inflate.xhtml) brush.

Relax Topology
:   Tries to create an even distribution of quads without deforming the volume of the mesh.
    This filter works the same as holding `Shift` with the
    [Slide Relax](../brushes/slide_relax.xhtml) brush.

Relax Face Sets
:   This will remove the jagged lines visible after drawing or creating a face set.
    This filter works the same as holding `Shift` with the
    [Draw Face Set](../brushes/draw_facesets.xhtml) brush.

Sharpen
:   Sharpens and smooths the mesh based on its curvature,
    resulting in pinching hard edges and polishing flat surfaces.
    Especially useful when sculpting hard surfaces and stylized models
    with creasing and flattening brushes.

Enhance Details
:   Increases the high frequency surface details of the mesh
    by intensifying the difference between creases and valleys.
    This filter works similar to the inverted direction of the
    [Smooth](../brushes/smooth.xhtml) brush.

Erase Multires Displacement
:   Deletes displacement information of
    the [Multires Modifier](../../../modeling/modifiers/generate/multiresolution.xhtml),
    resetting the mesh to a regular subdivision surface result.
    This can be used to reset parts of the sculpt or to fix reprojection artifacts
    after applying a [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.xhtml).

    Negative strokes will intensify the displacement details,
    this method works similar to *Enhance Details* and can give better results in some circumstances.

Randomize
:   Randomly moves vertices along the vertex normal.
    This filter works similar to the [Randomize Transform](../../../scene_layout/object/editing/transform/randomize.xhtml#bpy-ops-object-randomize-transform).
user: What is GeometryNodeSplitToInstances(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSplitToInstances(GeometryNode)

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

*class* bpy.types.GeometryNodeSplitToInstances(*GeometryNode*)
:   Create separate geometries containing the elements from the same group

    domain
    :   Attribute domain for the Selection and Group ID inputs

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Distribute Points in Volume from the Blender manual or Python API, including usage steps and snippets.

assistant: # Distribute Points in Volume

[image reference removed]

The *Distribute Points in Volume* node creates points inside of volume grids.
The node has two basic modes of operation: distributing points randomly, or in
a regular grid. Both methods operate on all of the float grids in the volume.
user: Provide the full official documentation entry for Logging Options, preserving all code examples.

assistant: `--log` `<match>`
:   Enable logging categories, taking a single comma separated argument.

    `--log "*"`: everything
    `--log "event"`: every category starting with `event`.
    `--log "render,cycles"`: both render and cycles messages.
    `--log "*mesh*"`: every category containing `mesh` sub-string.
    `--log "*,^operator"`: everything except operators, with `^prefix` to exclude.

`--log-level` `<level>`
:   Set the logging verbosity level.

    fatal: Fatal errors only
    error: Errors only
    warning: Warnings
    info: Information about devices, files, configuration, operations
    debug: Verbose messages for developers
    trace: Very verbose code execution tracing

`--log-show-memory`
:   Show memory usage for each log message.

`--log-show-source`
:   Show source file and function name in output.

`--log-show-backtrace`
:   Show a back trace for each log message (debug builds only).

`--log-file` `<filepath>`
:   Set a file to output the log to.

`--log-list-categories`
:   List all available logging categories for `--log`, and exit.
user: Give a detailed overview of Viewport Display: syntax, arguments, return values, common patterns.

assistant: # Viewport Display

This panel lets you configure display options for the 3D Viewport.

[image reference removed]

Viewport Display panel.

Show
:   Name
    :   Displays the object’s name in the 3D Viewport.

    Axes
    :   Displays an object similar to an empty that shows the object’s orientation.

    Wireframe
    :   Displays the object’s wireframe on top of the solid display.

    All Edges
    :   Displays all wireframe edges. This overrides the
        [wireframe threshold](../../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-wireframe-threshold)
        that you can set in the 3D Viewport’s overlay settings.

    Texture Space
    :   Displays the object’s [Texture Space](../../../glossary/index.xhtml#term-Texture-Space) in the 3D Viewport..
        The texture space overlay can be disabled for all objects using the
        [Extras Overlay](../../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-extras).

    Shadow
    :   Allows the object to cast shadows in the viewport.

    In Front
    :   Makes the object display in front of others. Unsupported for instanced objects.
        Limited support in the *Material Preview* and *Rendered* shading modes
        (works for e.g. armatures, but not for meshes).

Display As
:   Lets you display the object with less detail, going from removing the textures to
    only showing a bounding box. This can be useful if you have a high-poly object
    that is slowing down the viewport.

Color
:   The object’s color in the *Wireframe* and *Solid* viewport shading modes.
    Used when the viewport’s [(Wire) Color](../../../editors/3dview/display/shading.xhtml#viewport-shading-solid-color)
    shading option is set to *Object*.

Bounds
:   Displays a bounding shape around an object. You can choose between different
    primitive shapes that might be closer to what the original object looks like.
user: Provide the full official documentation entry for Trim Hair Curves, preserving all code examples.

assistant: # Trim Hair Curves

The *Trim Hair Curves* node shortens or scales hair curves based on a specified length or length factor.
It can be used to precisely control the overall length of hair, create varied or randomized trims,
or adjust groom density and layering.
user: Explain Metadata in complete detail according to the official Blender documentation.

assistant: Metadata on parameters controls how they are displayed in the user interface.
The following metadata entries are supported:

`[[ string label = "My Label" ]]`
:   Custom display name of the parameter in the user interface.

`[[ string widget = "null" ]]`
:   Hides the parameter from the user interface.

`[[ string widget = "boolean" ]]` or `[[ string widget = "checkbox" ]]`
:   Displays an integer parameter as a boolean checkbox.

`[[ string widget = "filename" ]]`
:   Displays the parameter as a file path selector.

`[[ string widget = "mapper", string options = "left:0|right:1" ]]`
:   Displays an integer parameter as an enumerated menu.
    The *options* string defines a list of label-value pairs separated by `|`.

`[[ string vecsemantics = "POINT" ]]`
:   Marks a vector parameter as a translation input (position vector).

`[[ string vecsemantics = "NORMAL" ]]`
:   Marks a vector parameter as a normal input (direction vector).

`[[ string unit = "radians" ]]`
:   Marks a float parameter as an angle input, displayed in radians.

`[[ string unit = "m" ]]`
:   Marks a float parameter as a distance input, displayed in meters.

`[[ string unit = "s" ]]` or `[[ string unit = "sec" ]]`
:   Marks a float parameter as a time input, displayed in seconds.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Vector
:   The coordinates at which Gabor noise will be evaluated. The Z component is ignored in the 2D
    case. Defaults to *Generated* texture coordinates if the socket is left unconnected.

Scale
:   Scale of the Gabor noise.

Frequency
:   The rate at which the Gabor noise changes across space. This is different from the Scale input
    in that it only scales perpendicular to the Gabor noise direction.

Anisotropy
:   The directionality of Gabor noise. 1 means the noise is completely directional, while 0 means
    the noise is omnidirectional.

Orientation
:   The direction of anisotropic Gabor noise. This is an angle for the 2D case, while it is a unit
    direction vector for the 3D case.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`NodeEvaluateClosure.input_items`](bpy.types.NodeEvaluateClosure.html#bpy.types.NodeEvaluateClosure.input_items "bpy.types.NodeEvaluateClosure.input_items") - [`NodeEvaluateClosureInputItems.new`](bpy.types.NodeEvaluateClosureInputItems.html#bpy.types.NodeEvaluateClosureInputItems.new "bpy.types.NodeEvaluateClosureInputItems.new") | - [`NodeEvaluateClosureInputItems.remove`](bpy.types.NodeEvaluateClosureInputItems.html#bpy.types.NodeEvaluateClosureInputItems.remove "bpy.types.NodeEvaluateClosureInputItems.remove") |
user: What is Subtract Strip and how is it used in Blender Python scripting?

assistant: # Subtract Strip

This effect takes away one strip’s color from the second.

Make a negative of an image using this effect,
or switch the order of the strips and just darken the strip.
Subtracting a hue of blue from a white image will make it yellow,
since red and green make yellow.
user: Explain Catalog Definition Files in complete detail according to the official Blender documentation.

assistant: Asset catalogs are stored in Catalog Definition Files (CDFs). Blender 3.0 supports a single CDF per asset library.
It is stored in `blender_assets.cats.txt` in the root directory of the asset library. If the file does not exist,
Blender will create it when the catalogs are saved. When catalogs are changed, Blender updates that file, but also
creates a backup of the previous state to a file named `blender_assets.cats.txt~`.

### Which File to Write To

Asset catalogs can be saved independently of the blend-file; the catalog editor has its own “Save” button.

### Format

Catalog Definition Files (CDFs) are relatively simple text files, encoded in UTF-8.
Each CDF consists of a version indicator, and a line of text per catalog.
Each catalog line is colon-separated, of the form `{UUID}:{path}:{simple name}`.

### Example

This is an example of a valid catalog definition file:

```
# This is an Asset Catalog Definition file for Blender.
#
# Empty lines and lines starting with `#` will be ignored.
# The first non-ignored line should be the version indicator.
# Subsequent lines are of the format "CATALOG_UUID:catalog/path/for/assets:simple catalog name"

VERSION 1

313ea471-7c81-4de6-af81-fb04c3535d0e:catalog/without/simple/name:
ee9c7b60-02f1-4058-bed6-539b8d2a6d34:character/Ellie/poselib:character-Ellie-poselib
cd66bf52-58f4-45cb-a4e2-dc0e0ee8f3fe:character/Ellie/poselib:character-Ellie
4eb44ec6-3424-405b-9782-ca006953e799:character/Ellie/poselib/white space:character-Ellie-poselib-white space
b63ed357-2511-4b96-8728-1b5a7093824c:character/Ružena/poselib:Ružena pose library
dcdee4df-926e-4d72-b995-33106983bb9a:character/Ružena/poselib/face:Ružena face
fb698f2e-9e2b-4146-a539-3af292d44899:character/Ružena/poselib/hand:Ružena hands
```

### Valid Catalog Paths

Catalog paths follow the following rules:

- All paths are absolute; there is no difference between `/a/b` and `a/b`.
- Only `/` as separator (no `\`; think less filesystem path and more URL).
- Not empty (it’s required for a valid catalog).
- No empty components (so not `a//b`; `a/b` is fine).
- Invalid characters: `:`, `\`.
- Paths are always interpreted as UTF-8.