PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe – Wireframe from the Blender manual or Python API, including usage steps and snippets.

assistant: Only displays the edges (wireframes) of the objects in the scene.

Wireframe Color
:   How wireframes are colored. This affects the Wireframe shading mode and overlay.

    Theme:
    :   Use the *Active Object*, *Wire*, or *Wire Edit* [theme color](../../preferences/themes.xhtml)
        based on the object’s current state.

    Object:
    :   Use the color from the object’s
        [Viewport Display](../../../render/workbench/display_settings.xhtml#properties-object-viewport-display) settings.

    Random:
    :   Each object gets displayed in a random color.

Background
:   How the background is displayed in the 3D Viewport.

    Theme:
    :   Use the background of the theme. This can be configured in the
        [Themes Preferences](../../preferences/themes.xhtml)
        under 3D Viewport ‣ Theme Space ‣ Gradient Colors.

    World:
    :   Use the color from the [World](../../../render/lights/world.xhtml)’s Viewport Display options.

    Custom:
    :   Select a custom color for the background of the 3D Viewport.

### Options

X-Ray `Alt`-`Z`
:   Make objects transparent, allowing you to see and select items that would otherwise be occluded.
    The slider controls object opacity.

Outline
:   Draw an outline around objects. The color of the outline can be adjusted.
user: Provide the full official documentation entry for Fly & Walk, preserving all code examples.

assistant: View Navigation
:   The default mode for interactive first person navigation.

    See [Fly/Walk Navigation](../3dview/navigate/walk_fly.xhtml#dview-fly-walk).

### Walk

Reverse Mouse
:   Inverts the mouse’s Y movement.

Mouse Sensitivity
:   Speed factor for when looking around, high values mean faster mouse movement.

Teleport Duration
:   Interval of time warp when teleporting in navigation mode.

Walk Speed
:   Base speed for walking and flying.

Speed Factor
:   The multiplication factor for the speed boost.

### Gravity

Simulates the effect of gravity when walking.

View Height
:   The distance from the ground floor to the camera when walking.

Jump Height
:   The maximum height of a jump.
user: Describe Custom Region from the Blender manual or Python API, including usage steps and snippets.

assistant: Enables or disables the use of a *Custom Region* for UV operations such as
[Pack Islands](#bpy-ops-uv-pack-islands).

When enabled, the previously defined user region (created using
[Set User Region](#bpy-ops-uv-custom-region-set)) becomes active and visible in the UV Editor.
This region defines the boundaries where UV islands are packed or manipulated.

Disabling this option restores the default behavior, where UV operations apply to the
standard unit square or the active UDIM tile.
user: Show practical ways to work with Getting Support in a Blender add-on or script – include code.

assistant: Blender’s community is one of its greatest features, so apart from this user manual, there are many different ways to
get support from other users, such as [Chat](#blender-chat), [Stack Exchange](https://blender.stackexchange.com/),
and [Reddit](https://www.reddit.com/r/blender/).

For studios and organizations there is [Enterprise support](https://www.blender.org/support/), and for studios
looking to add Blender to their pipeline, [Blender Studio](https://studio.blender.org/) contains documentation and
training material around this topic. If you think you have found an issue with Blender, please [report a bug](https://projects.blender.org/blender/blender/issues/new?template=.gitea%2fissue_template%2fbug.yaml).

More details about support can be found on the [support page](https://www.blender.org/support/).
user: Explain Color in complete detail according to the official Blender documentation.

assistant: Saturation
:   Adjusts the vividness of colors in the image.

Multiply
:   Multiplies the colors by this value. This will increase the brightness.

Multiply Alpha
:   Multiply alpha along with color channels when using the *Multiply* option.

Convert to Float
:   Converts input to float data.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: Empties can serve as transform handles. Some examples of ways to use them include:

Parent object for a group of objects

An empty can be parented to any number of other objects.
This gives the user the ability to control a group of objects easily, and without affecting a render.

Target for constraints

An empty can also be used as a target for normal, or bone constraints.
This gives the user far more control; for instance,
a rig can easily be set up to enable a camera to point towards an empty using the *Track to* constraint.

Array offset

An empty can be used to offset an Array Modifier,
meaning complex deformations can be achieved by only moving a single object.

|  |  |
| --- | --- |
| ../_images/modeling_modifiers_generate_array_example-fractal-1.jpg   An example of an empty being used to control an array. | ../_images/modeling_empties_example-track-to-simple.png   An example of an empty being used to control the Track To constraint. |

Other common uses:

- Placeholders
- Rigging controls
- DOF distances
- Reference Images
user: Give a detailed overview of Scaling Rigid Bodies: syntax, arguments, return values, common patterns.

assistant: Rigid body objects can be scaled, also during the simulation.
This work well in most cases, but can sometimes cause problems.

If dynamic scaling is not needed, rigid body objects should have the scale applied by
using the *Apply Scale* tool `Ctrl`-`A`.
user: Describe Masks from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Masks panel.

In Grease Pencil there are no special mask layers, any layer can act as a mask for other layers.
The mask system is flexible enough to allow top-bottom and bottom-top masking.

Layers used as masks can use all the blend modes and different opacity values like any other layer.

The layer/s that will act as mask of the current layer could be added
to the Mask [list view](../../interface/controls/templates/list_view.xhtml#ui-list-view).

In the Masks list next to the layers name there are two icons buttons that control
common properties of the layer mask:

Invert (mask icon)
:   Inverts the mask.

Viewport/Render Visibility (eye icon)
:   Toggle layer visibility in the viewport and in render.

Mask (green circle) samples.

|  |  |  |
| --- | --- | --- |
| ../../_images/grease-pencil_properties_masks_example-01.png   Original image (Blend: Regular, Opacity: 1). | ../../_images/grease-pencil_properties_masks_example-02.png   Blend: Hard Light, Opacity: 1. | ../../_images/grease-pencil_properties_masks_example-03.png   Blend: Regular, Opacity: 1. |
user: Provide the full official documentation entry for Color, preserving all code examples.

assistant: Saturation
:   Adjusts the vividness of colors in the image.

Multiply
:   Multiplies the colors by this value. This will increase the brightness.

Multiply Alpha
:   Multiply alpha along with color channels when using the *Multiply* option.

Convert to Float
:   Converts input to float data.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Blender provides a variety of operators for editing meshes.
These operators are used to add, duplicate, move and delete elements.

These are available through the Menus in the 3D Viewport header, and context menus in the 3D Viewport,
as well as individual shortcut keys.

These transform operators are available in the *Transform* section of the *Mesh* menu in the header.
Note that, some of these can also be used on other editable objects, like curves, surfaces, and lattices.
user: What is Mesh Edit Mode Overlays and how is it used in Blender Python scripting?

assistant: The following options are available when in Mesh Edit Mode.

Faces
:   Highlight selected faces. Affects all selection modes.

Center
:   Show face center points in solid shading modes. (They’re always shown in wireframe shading mode.)

    Only affects face selection mode.

Creases
:   Display edges marked with a crease
    for the [Subdivision Surface Modifier](../../../modeling/modifiers/generate/subdivision_surface.xhtml).

Sharp
:   Display sharp edges, used with the [Edge Split modifier](../../../modeling/modifiers/generate/edge_split.xhtml).

Bevel
:   Display weights created for the [Bevel Modifier](../../../modeling/modifiers/generate/bevel.xhtml).

Seams
:   Display the [UV unwrapping seams](../../../modeling/meshes/uv/unwrapping/seams.xhtml).

Indices
:   Display the indices of selected vertices, edges, and faces.

### Shading

Retopology
:   This overlay is useful when you have a sculpted mesh with the desired shape and
    want to recreate it with better topology. It makes the edited mesh see-through
    (so that you can see the sculpted mesh underneath it) and optionally renders it
    in front of nearby geometry (so that you can see it underneath the sculpted mesh).

    Offset
    :   Distance to “move the edited mesh towards the camera.” Use this to display the
        mesh in front of other objects that would normally occlude it.

Vertex Groups Weights
:   Visualize the weights of the active vertex group,
    much like in [Weight Paint](../../../sculpt_paint/weight_paint/introduction.xhtml) mode.

    Zero Weights
    :   Display unreferenced and zero-weighted areas in black.
        This helps to identify areas with very low weights that have been painted onto.

        None:
        :   Vertices are displayed in the usual way.

        Active:
        :   Vertices are shown in black if they have no weight in the active vertex group.

        All:
        :   Vertices are shown in black if they have no weight in any vertex group.

### Mesh Analysis

Show the [Mesh Analysis](../../../modeling/meshes/mesh_analysis.xhtml#modeling-mesh-analysis) overlay.

### Measurement

Show numerical measures of the selected elements.
The [Units](../../../scene_layout/scene/properties.xhtml#bpy-types-unitsettings) can be set in the Scene properties.

Edge Length
:   Show the length of selected edges.

Edge Angle
:   Show the angle of selected edges between two faces.

Face Area
:   Show the area of selected faces.

Face Angle
:   Show the angle of selected face corners.

### Normals

- Display vertex normals
- Display face normals at vertices (split normals)
- Display face normals

Size
:   The size to show the selected normals.

    Constant Screen Size Normals
    :   Keep the size of normals constant in relation to the zoom level.

### Freestyle

These settings apply to the [Freestyle](../../../render/freestyle/introduction.xhtml)
Line Art renderer.

Edge Marks
:   Display Freestyle edge marks.

Face Marks
:   Display Freestyle face marks.
user: Explain VFX Platform in complete detail according to the official Blender documentation.

assistant: Blender follows the [VFX reference platform](https://vfxplatform.com),
which means it is able to run on the same systems as other VFX software
and exchange image, volume and scene files with them.

### Python Version

Blender and the [bpy module](https://pypi.org/project/bpy/) are only compatible
with a single Python version. This makes it possible for add-ons and VFX software
in general to only have to target a single Python version.

Blender bundles a complete Python installation and does not interact with the
system Python by default. This can be changed with the `--python-use-system-env`
[command line argument](command_line/arguments.xhtml#command-line-args-python-options), if care is
taken to set up a compatible Python version.
user: How do I use 2D Cursor in Blender? Include parameters, examples, warnings and best practices.

assistant: Just like the [3D Viewport](../3dview/3d_cursor.xhtml), the UV Editor has a Cursor
that you can jump to (View ‣ Center View to Cursor). It can also serve as
a [pivot point](../3dview/controls/pivot_point/index.xhtml) and a
[snapping target](../../modeling/meshes/uv/editing.xhtml#bpy-ops-uv-snap-selected).

To change the Cursor’s position, either press `LMB` with the Cursor tool selected,
or `Shift`-`RMB` with any tool selected. You can also change the “Location X/Y” fields
in the *View* tab of the Sidebar, in either relative coordinates (0 to 1) or
[pixel coordinates](sidebar.xhtml#bpy-types-spaceuveditor-show-pixel-coords).
In both cases, the lower left corner of the image serves as the origin (0, 0).

You can press `Shift`-`C` to move the Cursor to the center.
user: What is Bpy.Types.Distortednoisetexture and how is it used in Blender Python scripting?

assistant: property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values ID.bl_system_properties_get ID.rename ID.evaluated_get ID.copy ID.asset_mark ID.asset_clear ID.asset_generate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py Texture.evaluate Texture.bl_rna_get_subclass Texture.bl_rna_get_subclass_py Next DopeSheet(bpy_struct) Previous DisplaySafeAreas(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page DistortedNoiseTexture(Texture) DistortedNoiseTexture DistortedNoiseTexture.distortion DistortedNoiseTexture.nabla DistortedNoiseTexture.noise_basis DistortedNoiseTexture.noise_distortion DistortedNoiseTexture.noise_scale DistortedNoiseTexture.users_material DistortedNoiseTexture.users_object_modifier DistortedNoiseTexture.bl_rna_get_subclass() DistortedNoiseTexture.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Visibility Area
:   Determines whether all vertices inside or outside the selected area should be affected.

    Inside:
    :   All vertices and connected elements inside the selection area will be hidden.

    Outside:
    :   All vertices and connected elements outside the selection area will be hidden.
user: Describe ShaderNodeWireframe(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeWireframe(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.ShaderNodeWireframe(*ShaderNode*)
:   Retrieve the edges of an object as it appears to Cycles.
    Note: as meshes are triangulated before being processed by Cycles, topology will always appear triangulated

    use_pixel_size
    :   Use screen pixel size instead of world units

        Type:
        :   boolean, default False

    *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: Show practical ways to work with 2D Offset in a Blender add-on or script – include code.

assistant: # 2D Offset

The *2D Offset* modifier adds some two-dimensional offsets to the stroke backbone geometry.
It has two sets of independent options/effects:

Start, End
:   These two options add the given amount of offset to the start (or end) point of the stroke,
    along the (2D) normal at those points. The effect is blended over the whole stroke, if you for example,
    set only *Start* to 50, the start of the stroke is offset 50 pixels along its normal,
    the middle of the stroke, 25 pixels along its own normal, and the end point is not moved.

X, Y
:   These two options simply add a constant horizontal and/or vertical offset to the whole stroke.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`AssetLibraryCollection.new`](bpy.types.AssetLibraryCollection.html#bpy.types.AssetLibraryCollection.new "bpy.types.AssetLibraryCollection.new") - [`AssetLibraryCollection.remove`](bpy.types.AssetLibraryCollection.html#bpy.types.AssetLibraryCollection.remove "bpy.types.AssetLibraryCollection.remove") | - [`PreferencesFilePaths.asset_libraries`](bpy.types.PreferencesFilePaths.html#bpy.types.PreferencesFilePaths.asset_libraries "bpy.types.PreferencesFilePaths.asset_libraries") |
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: X, Y, Z
:   The integer indices of the current voxel in the grid along each axis.

    These values identify which voxel is being sampled by the field at this
    evaluation point. They can be offset (for example, add or subtract 1 on X)
    and then passed to [Sample Grid Index](../sample/sample_grid_index.html)
    to read values from neighboring voxels.

### Tile

Is Tile
:   Whether the current evaluation is happening on a *tile* rather than on a
    single voxel.

    Some operations evaluate fields on tiles that cover multiple voxels at
    once for performance reasons. In those cases the coordinates given by
    *X*, *Y*, and *Z* alone are not enough to describe the full covered region.

    If this is false, the extent is always 1.

Extent X, Extent Y, Extent Z
:   The number of voxels along each axis of the tile.

    For a normal voxel, the extent on each axis is `1`.
    For a tile that covers multiple voxels, the extents describe how many
    voxels are grouped together in X, Y, and Z.

    These outputs can be used to detect and handle cases where an evaluation
    represents an aggregated region (a tile) instead of an individual voxel,
    so that the result is not misinterpreted as referring to just one voxel.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`CameraBackgroundImage.image_user`](bpy.types.CameraBackgroundImage.html#bpy.types.CameraBackgroundImage.image_user "bpy.types.CameraBackgroundImage.image_user") - [`Image.filepath_from_user`](bpy.types.Image.html#bpy.types.Image.filepath_from_user "bpy.types.Image.filepath_from_user") - [`ImageTexture.image_user`](bpy.types.ImageTexture.html#bpy.types.ImageTexture.image_user "bpy.types.ImageTexture.image_user") - [`Object.image_user`](bpy.types.Object.html#bpy.types.Object.image_user "bpy.types.Object.image_user") - [`RenderSlot.clear`](bpy.types.RenderSlot.html#bpy.types.RenderSlot.clear "bpy.types.RenderSlot.clear") - [`ShaderNodeTexEnvironment.image_user`](bpy.types.ShaderNodeTexEnvironment.html#bpy.types.ShaderNodeTexEnvironment.image_user "bpy.types.ShaderNodeTexEnvironment.image_user") | - [`ShaderNodeTexImage.image_user`](bpy.types.ShaderNodeTexImage.html#bpy.types.ShaderNodeTexImage.image_user "bpy.types.ShaderNodeTexImage.image_user") - [`SpaceImageEditor.image_user`](bpy.types.SpaceImageEditor.html#bpy.types.SpaceImageEditor.image_user "bpy.types.SpaceImageEditor.image_user") - [`TextureNodeImage.image_user`](bpy.types.TextureNodeImage.html#bpy.types.TextureNodeImage.image_user "bpy.types.TextureNodeImage.image_user") - [`UILayout.template_image`](bpy.types.UILayout.html#bpy.types.UILayout.template_image "bpy.types.UILayout.template_image") - [`UILayout.template_image_layers`](bpy.types.UILayout.html#bpy.types.UILayout.template_image_layers "bpy.types.UILayout.template_image_layers") |
user: What is ThemeProperties(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ThemeProperties(bpy_struct)

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

*class* bpy.types.ThemeProperties(*bpy_struct*)
:   Theme settings for the Properties

    match
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    space
    :   Settings for space

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Split

The *Split* operator disconnects selected bones from the rest of the armature,
creating a new, unconnected bone chain.

This is useful for restructuring rigs, separating limbs, or preparing bone chains to be transformed independently.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Clear Delta
:   Clear the [delta transform](../properties/transforms.html#bpy-types-object-delta) in addition to clearing the primary transforms.
    (Appears in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.)
user: Explain ShaderNodeBsdfToon(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeBsdfToon(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.ShaderNodeBsdfToon(*ShaderNode*)
:   Diffuse and Glossy shaders with cartoon light effects

    component
    :   Toon BSDF component to use

        - `DIFFUSE`
          Diffuse – Use diffuse BSDF.
        - `GLOSSY`
          Glossy – Use glossy BSDF.

        Type:
        :   enum in [`'DIFFUSE'`, `'GLOSSY'`], default `'DIFFUSE'`

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

assistant: # Resample Curve Node

[image reference removed]

The Resample Curve node creates a poly spline for each input spline.
In the *Count* and *Length* modes, the control points of the new poly
splines will have uniform spacing.
user: How do I use Mask Filters in Blender? Include parameters, examples, warnings and best practices.

assistant: Similarly to other [Filter Tools](../introduction/filters.html),
mask filters are operations that are applied to the whole mask.

Type
:   Smooth/Sharpen Mask
    :   Changes the sharpness of the mask edge.
        Using this can be faster and more consistent than smoothing the mask
        with the [Mask](../brushes/mask.html) brush.

    Grow/Shrink Mask
    :   Further grow or shrink the mask along the surface of the mesh.

    Increase/Decrease Contrast
    :   Changes the contrast of the mask.

In the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel there are further options
to add iterations for a stronger effect.

Iterations
:   The number of times the filter is applied.

Auto Iteration Count
:   Use an automatic number of iterations based on the number of vertices of the sculpt.
    Disable this option to set the Iterations manually.
user: Describe Relations from the Blender manual or Python API, including usage steps and snippets.

assistant: # Relations

Parent
:   The object to which the selected object is parented to.

Parent Type
:   The type of parenting used. See [parenting](../editing/parent.html)
    for information on the different types.

Use Final Indices Vertex 3 Vertices
:   Use the final evaluated indices rather than the original mesh indices.

Camera Parent Lock
:   When the camera is locked to the view, the root parent is transformed rather than the camera.
    This is useful for camera rigs where you don’t want to animate the camera directly.

Parent Vertex/Vertices
:   Indices of vertices in case of a vertex parenting relation.

Tracking Axis
:   Axis that points in the “forward” direction.
    Applies to *Instance Vertices* when *Align to Vertex Normal* is enabled.

Up Axis
:   Axis that points in the “upward” direction.
    Applies to *Instance Vertices* when *Align to Vertex Normal* is enabled.

Pass Index
:   Defines the index the object will have in the Object Index render pass. See [passes](../../../render/layers/passes.html)
    and [ID mask](../../../compositing/types/mask/id_mask.html) for more information.
user: Explain GeometryNodeSplineParameter(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSplineParameter(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.GeometryNodeSplineParameter(*GeometryNode*)
:   Retrieve how far along each spline a control point is

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Noise

The *Noise* modifier uses a pseudo-random number generator to variably distribute the property along the stroke.

Amplitude
:   The maximum value of the noise. A higher amplitude means a less transparent (more solid) stroke.

Period
:   The period of the noise. This means how quickly the property value can change.
    A higher value means a more smoothly changing color along the stroke.

Seed
:   Seed used by the pseudo-random number generator.

Asymmetric Thickness only
:   Allows the thickness to be distributed unevenly at every point.
    Internally, the stroke is represented as a backbone with a thickness to the right and left side.
    All other thickness shaders make sure that the left and right thickness values are equal.
    For the Noise shader however, a meaningful (and good-looking) result
    can be created by assigning different values to either side of the backbone.

[image reference removed]

Effect generated with a noise thickness modifier using asymmetric thickness.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Array modifier.

Count
:   Total number of copies.

Material Override
:   Index of the material to use on duplicated strokes (0 use strokes original materials).

### Relative Offset

Factor X, Y, Z
:   Adds a translation equal to the object’s bounding box size along each axis,
    multiplied by a scaling factor, to the offset. X, Y and Z scaling factors can be specified.

### Constant Offset

Factor X, Y, Z
:   Adds a constant translation component to the duplicate object’s offset.
    X, Y and Z constant components can be specified.

### Object Offset

Distance X, Y, Z
:   Adds a transformation taken from an object (relative to the current object) to the offset.
    It is good practice to use an empty object centered or near to the initial object.

### Randomize

Offset X, Y, Z
:   Add random offset values to the copies.

Rotation X, Y, Z
:   Add random rotation values to the copies.

Scale X, Y, Z
:   Add random scale values to the copies.

Uniform Scale
:   Use the same random *Seed* for each scale axis in the copies for a uniform scale.

Seed
:   [Seed](../../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   The values to be accumulated.

Group Index
:   An index used to group values together for multiple separate accumulations.
    This can be thought of as a choice of the “bin” in which to place each value.
    This input has no effect when it is only a single value.
user: Explain MESH_UL_attributes(UIList) in complete detail according to the official Blender documentation.

assistant: # MESH_UL_attributes(UIList)

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

*class* bpy.types.MESH_UL_attributes(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *attribute*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    filter_items(*_context*, *data*, *property*)

    *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 FunctionNodeValueToString(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeValueToString(FunctionNode)

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

*class* bpy.types.FunctionNodeValueToString(*FunctionNode*)
:   Generate a string representation of the given input value

    data_type
    :   - `FLOAT`
          Float – Floating-point value.
        - `INT`
          Integer – 32-bit integer.

        Type:
        :   enum in [`'FLOAT'`, `'INT'`], default `'FLOAT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Sequencer Scene

The video sequencer uses a separate scene data-block that contains the edit. This is the *Sequencer Scene*.

Having a separated scene for the video sequencer has multiple benefits, like managing different
versions of an edit within the same file. Another important use-case is working with
different scenes in the file and scene strips. See the section below about working with multiple scenes
and scene strips.
user: How do I use Named Attributes Overlay in Blender? Include parameters, examples, warnings and best practices.

assistant: The “Named Attributes” overlay allows displaying when a custom named attribute is used
by a node or a node group. Named attributes can be used by the
[Capture Attribute Node](attribute/capture_attribute.xhtml), the
[Named Attribute Node](geometry/read/named_attribute.xhtml), and the
[Remove Named Attribute Node](attribute/remove_named_attribute.xhtml),
and can be written to, read, or removed.

Using named attributes (as opposed to [Anonymous Attributes](attributes_reference.xhtml#anonymous-attributes)) can be problematic
when the original geometry already has attributes with the specified names. In that case
a geometry node group might mistakenly overwrite some essential data. The overlay helps
to make detecting that situation easy.

The same data is also available in the [Named Attributes](../modifiers/geometry_nodes.xhtml#modifiers-geometry-nodes-named-attributes) panel
in the modifier’s UI.
user: Describe Musgrave Texture Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Musgrave Texture Node

The Musgrave texture node was replaced by the
[Noise Texture](noise.html) node,
which includes all the same functionality.

- The Dimension input was replaced by a Roughness input, where \(Roughness = Lacunarity^{-Dimension}\).
- The Detail input value must be subtracted by 1 compared to the old Musgrave Texture node.
user: Explain Texture Slots in complete detail according to the official Blender documentation.

assistant: # Texture Slots

[image reference removed]

Texture Slots settings.

The combination of images associated with UV maps is called “slots”.

Selecting a *Paint Slots* or *Canvas Image*
will also display the corresponding image in the Image Editor.

Mode
:   The slot system includes two painting modes:

    Material
    :   This mode tries to detect the slots from the materials of the mesh.

        For the Cycles renderer, all textures (*Image Texture* node) in the material’s node tree
        are added in the slots tab.

        Active Paint Texture Index
        :   A [List view](../../../interface/controls/templates/list_view.xhtml#ui-list-view) of slots.
            Activate a certain slot to use it for painting by `LMB` click on it.

    Single Image
    :   You can just select an existing image and painting will use the active UV layer for painting.

        Image
        :   Allows you to select the image used as a canvas.

            New
            :   Create a new image.

        UV Map
        :   Allows you to select the UV layer for painting.
            (Same as the currently active UV map in the mesh’s *UV Maps* panel.)

        Texture Filter Type
        :   Set the interpolation mode of the texture. This can be Linear or Closest.

Save All Images
:   Repack (or save if external file) all edited images.
    Same as in the [Image Editor](../../../editors/image/introduction.xhtml).

Add Simple UVs
:   The *Add Simple UVs* does a simple cube unwrap followed by a pack operation.
    It’s still recommended to make a custom unwrap.

    This operator is available when the object does not already have a UV Map.
user: How do I use Sculpt Mode in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

3D Viewport Mode selector: Sculpt Mode.

Sculpt Mode is selected from the *Mode* menu in the 3D Viewport header.
Once Sculpt Mode is activated, the Toolbar of the 3D Viewport will change to
Sculpt Mode specific panels.
A red circle will appear and follow the location of the cursor in the 3D Viewport.
user: Explain In Edit Mode in complete detail according to the official Blender documentation.

assistant: When in Edit Mode, rotation and scaling happen around the centerpoint of
the active element, which is the element with a white outline.
That centerpoint remains in the same location while everything else
is transformed around it.

The image below illustrates rotation around the active vertex,
edge, and face. Each time, the active element rotates in place,
while the others “orbit” around it. In the case of vertices,
the active vertex is not changed at all, as a vertex on its own
is just a point that has no concept of rotation.

[image reference removed]

Left column: starting situation, right column: after rotation.
user: What is Precompiled Libraries and how is it used in Blender Python scripting?

assistant: While not common practice, Python add-ons can be distributed with their own precompiled libraries. Unlike regular
Python scripts, these are not portable between different platforms.

It is possible the library is incompatible with your Blender installation (attempting to load a library built for a
different version of Python, or loading a 32-bit library on a 64-bit system).

If the add-on contains `.pyd` or `.so` files, check that the distribution is compatible with your operating
system.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Mode
:   Vertices:
    :   Points are generated for each vertex.

    Edges:
    :   Points are generated for each edge, at the middle of each edge, by default.

    Faces:
    :   Points are generated for each face, at the average of all of each face’s vertices, by default.

    Corners:
    :   Points are generated for each corner. The points are all placed at the location of each
        corners vertex, so they will overlap by default.
user: Explain Limitations in complete detail according to the official Blender documentation.

assistant: - [Path Guiding](render_settings/sampling.xhtml#bpy-types-cyclesrendersettings-use-guiding) is not supported on any GPU.
- [Open Shading Language](osl/index.xhtml) is only supported for OptiX, with some limitations listed in the documentation.
user: Provide the full official documentation entry for Splines, preserving all code examples.

assistant: Splines are the fundamental components of curve objects, defining their shapes.
A curve object can consist of multiple splines,
similar to how a mesh object can contain multiple disconnected meshes.
Each spline’s shape is determined by its [Control Points](../curves/structure.xhtml#curve-spline-types).
Splines come in several types: Poly, Bézier, and NURBS, each with its own algorithm for representing curves,
as described in the [Spline Types](#spline-types) section.

### Control Points

Splines are made up of control points, which connect to form the spline.
Control points can be [selected](../curves/selecting.xhtml) and transformed to adjust the spline’s shape.
This is analogous to vertices in a mesh object.
user: Provide the full official documentation entry for Vector Displacement Node, preserving all code examples.

assistant: # Vector Displacement Node

[image reference removed]

The *Vector Displacement* node is used to displace the surface along arbitrary directions,
unlike the regular Displacement node which only displaces along the surface normal.

It is typically used to apply vector displacement maps created by other sculpting
software. Vector displacement maps can fully represent the high resolution detail to
be applied on a smooth base mesh, unlike regular displacement maps.

By default, Blender only uses [Bump Mapping](../../../glossary/index.html#term-Bump-Mapping) to render displacement.
However with true displacement, the rendered geometry will be physically displaced. To use true displacement
the [Displacement method](../../eevee/material_settings.html#bpy-types-material-displacement-method) must be set accordingly.
user: Show practical ways to work with Outliner in a Blender add-on or script – include code.

assistant: You can easily inspect the contents of your file by using the *Outliner* editor,
which displays all of the data in your blend-file.

The *Outliner* allows you to do simple operations on objects,
such as selecting, renaming, deleting, linking and parenting.

[Read more about the Outliner](../editors/outliner/index.xhtml).
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: ### Creating an Alpha Mask

An often overlooked use case of the Color Ramp is to turn a black-and-white image
into a colored image with transparency.

[image reference removed]

In the example above, a black-and-white swirl image, which is lacking an alpha channel,
is fed into the Color Ramp node as a *Factor*.

The Color Ramp node is set to a purely transparent color on the left end of the gradient,
and a fully red color on the right. As you can see in the Viewer node,
the Color Ramp node outputs an image that is transparent where the input is black,
and opaque where the input is white.

### Colorizing an Image

In this example, multiple colors are added to the color gradient,
converting a black-and-white image into a flaming swirl.

[image reference removed]

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.
user: Provide the full official documentation entry for Strokes Location & Orientation Controls, preserving all code examples.

assistant: Drawing in a 3D space is not the same as drawing on a flat canvas.
When drawing with Grease Pencil you have to define
the location and orientation of the new strokes in the 3D space.

[image reference removed]

3D Viewport header Controls for strokes.

### Stroke Placement

The Stroke Placement selector defines the new strokes location in 3D space.

See [Stroke Placement](stroke_placement.xhtml) for more information.

### Drawing Planes

The Drawing Planes selector defines the plane (orientation) to which the new strokes will be restricted.

See [Drawing Planes](drawing_planes.xhtml) for more information.
user: Describe Instances from the Blender manual or Python API, including usage steps and snippets.

assistant: # Instances

[image reference removed]

The three types of instances.

In addition to storing real data like a mesh or a curve, objects can store instances,
which themselves can reference more geometry, an object, or a collection. The purpose
of instancing is to allow duplicating geometry and storing it in an object, without duplicating
the actual data. This optimization allows render engines like [Cycles](../../render/cycles/index.html)
to handle the same geometry data in many different locations better than when the data is duplicated.

Each instance keeps track of which geometry it corresponds to
and how the instanced is transformed compared to it’s source geometry.
Instances can also store the `id` attribute,
which is used to correct motion blur when instances move in an animation.

Instances can be created with geometry nodes using the [Instance on Points Node](instances/instance_on_points.html).