PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for TextureNodeGroup(TextureNode), preserving all code examples.

assistant: # TextureNodeGroup(TextureNode)

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

*class* bpy.types.TextureNodeGroup(*TextureNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

    *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: Provide the full official documentation entry for Installing Dependencies, preserving all code examples.

assistant: Below are listed the installation commands for popular Linux distributions.

For the appropriate system, run the command in a terminal:

Debian/Ubuntu:

```
sudo apt-get install python3 python3-pip git git-lfs
git lfs install --skip-repo
```

Redhat/Fedora:

```
sudo dnf install python python-pip git git-lfs
git lfs install --skip-repo
```

Arch Linux:

```
sudo pacman -S python python-pip git git-lfs
git lfs install --skip-repo
```
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Scale
:   Overall texture scale.

Distortion
:   Amount of distortion of the wave.

Detail
:   Amount of distortion noise detail.

Detail Scale
:   Scale of distortion noise.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Phase Offset
:   Position of the wave along the *Bands Direction*.
    This can be used as an input for more control over the distortion.
user: Show practical ways to work with Areas in a Blender add-on or script – include code.

assistant: # Areas

[image reference removed]

Area boundaries are indicated by rounded corners (yellow highlights).

The Blender window is divided into a number of rectangles called Areas.
Areas reserve screen space for [Editors](../../editors/index.xhtml), such as the
[3D Viewport](../../editors/3dview/introduction.xhtml) or the
[Outliner](../../editors/outliner/introduction.xhtml).
Each editor offers a specific piece of functionality.

Areas are grouped into [Workspaces](workspaces.xhtml),
which are geared towards particular tasks (modeling, animating and so on).
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Value
:   The field to evaluate. Can be a float or a vector depending on the *Data Type*.
    For vector values, variance is computed separately per component (X, Y, Z).

Group ID
:   An index used to group values together for multiple separate variances.
    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: Give a detailed overview of Render: syntax, arguments, return values, common patterns.

assistant: Space
:   Specifies how volume density and step size are computed.

    Object:
    :   Keeps volume *Density* and *Detail* the same regardless of object scale.

    World:
    :   Specify *Step Size* and *Density* in world space.

Clipping Cycles Only
:   Value under which voxels are considered empty space to optimize rendering.

Precision Cycles Only
:   Specifies volume data precision. Lower values reduce memory consumption at the cost of detail.

    Full:
    :   Full float (Use 32 bit for all data).

    Half:
    :   Half float (Use 16 bit for all data).

    Variable:
    :   Automatically use less precision for less noticeable areas.

Velocity Grid Cycles Only
:   The name of the grid that contains voxel velocities, for calculating motion blur.
    This can be the name of a single grid containing 3D vectors,
    or a prefix of three separate grids containing scalar values.
    In the latter case, the X grid should have a name suffix of `x`, `.x` or `_x`,
    with similar conventions for the Y and Z grids.

Velocity Unit Cycles Only
:   Whether the velocity grid(s) specify distances per frame or per second.

Velocity Scale Cycles Only
:   A custom multiplier to apply to the velocities in the VDB.
user: Describe Pixel Filter from the Blender manual or Python API, including usage steps and snippets.

assistant: Due to limited resolution of images and computer screens, pixel filters are needed to avoid [Aliasing](../../../glossary/index.xhtml#term-Aliasing).
This is achieved by slightly blurring the image to soften edges.

Type
:   Pixel Filtering algorithm to use.

    Box:
    :   No filter.

    Gaussian:
    :   Smooth filter.

    Blackman-Harris:
    :   Default filter with a better balance between smoothness and detail preservation.

Width
:   Lower values give more crisp renders, higher values are softer and reduce aliasing.
user: What is Material Slots and how is it used in Blender Python scripting?

assistant: [image reference removed]

Grease Pencil material slots panel.

Next to the material name there are three icons buttons that control common properties of the material:

/ (Show/Hide in Ghosts)
:   Toggle the use of the material for [Onion Skinning](../properties/onion_skinning.html).

/ (Hide/Show Material)
:   Toggle whether the active material is the only one that can be edited and is visible.

/ (Lock/Unlock Material)
:   Toggle whether the active material is the only one that can be edited.

### Specials

Show All
:   Turns on the visibility of every material in the list.

Hide Others
:   Turns off the visibility of every material in the list except the active one.

Lock All
:   Locks editing of all the materials in the list.

Unlock All
:   Unlocks editing of all the materials in the list.

Lock Unselected
:   Locks all materials not used in the selected strokes.

Lock Unused
:   Locks and hides all unused materials.

Copy Material to Selected
:   Copy the active material to the selected Grease Pencil object.

Copy All Materials to Selected
:   Copy all materials to the selected Grease Pencil object.

Remove Unused Slots
:   Remove all unused materials.

### Lock & Visibility Controls

(Isolate Material)
:   Toggle whether the active material is the only one that can be edited.

(Isolate Material)
:   Toggle whether the active material is the only one that can be edited and is visible.
user: Describe GeometryNodeDualMesh(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeDualMesh(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.GeometryNodeDualMesh(*GeometryNode*)
:   Convert Faces into vertices and vertices into faces

    *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 References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`SpaceSequenceEditor.timeline_overlay`](bpy.types.SpaceSequenceEditor.html#bpy.types.SpaceSequenceEditor.timeline_overlay "bpy.types.SpaceSequenceEditor.timeline_overlay") |  |
user: What is Palette(ID) and how is it used in Blender Python scripting?

assistant: # Palette(ID)

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

*class* bpy.types.Palette(*ID*)
:   colors
    :   Type:
        :   [`PaletteColors`](bpy.types.PaletteColors.html#bpy.types.PaletteColors "bpy.types.PaletteColors") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`PaletteColor`](bpy.types.PaletteColor.html#bpy.types.PaletteColor "bpy.types.PaletteColor"), (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: Explain Particle Edit Mode in complete detail according to the official Blender documentation.

assistant: # Particle Edit Mode

Using *Particle Edit Mode* you can edit the keyed points (keyframes)
and paths of [Hair](hair/index.xhtml),
[Particle](index.xhtml), [Cloth](../cloth/index.xhtml), and
[Soft Body](../soft_body/index.xhtml) simulations. (You can also edit and style hair before baking.)

Since working in Particle Edit Mode is pretty easy and very similar
to working with vertices in the 3D Viewport, we will show how to set up
a particle system and then give a reference of the various functions.
user: What is Paste UVs and how is it used in Blender Python scripting?

assistant: For each selected UV island, the *Paste UVs* tool will attempt to match the topology of an island stored in the
internal clipboard. If a match is found, the UVs stored in the clipboard for the original island will be pasted
onto the currently selected island.

For example, if a triangle attached to a quad attached to a quad is in the clipboard, then a different triangle
<=> quad <=> quad is selected, then the topologies match, and the UVs will be pasted over the current selection.

For best results, you may want to use the Rip tool, or UV > Split > Selection, prior to using
*Paste UVs*.
user: Provide the full official documentation entry for Velocity, preserving all code examples.

assistant: [image reference removed]

Velocity panel.

This panel shows brush options that are based on object velocity.

On top you have a color ramp and several related settings.
Basically the color ramp represents brush velocity values:
left side being zero velocity and right side being the “Max velocity”.
Speed is measured in “units per frame”.

Checkboxes above can be used to define color ramp influence.

Multiply Alpha
:   Uses color ramp’s alpha value depending on current velocity and multiplies brush alpha with it.

Replace Color
:   Replaces the brush color with the values from the [Color Ramp Widget](../../interface/controls/templates/color_ramp.xhtml#ui-color-ramp-widget).

Multiply Depth
:   Multiplies brushes “depth intersection” effect.
    Basically you can adjust displace and wave strength depending on brush speed.

Do Smudge
:   Enabling Smudge makes the brush “smudge” (or “smear”) existing colors on the surface as it moves.
    The strength of this effect can be defined from the *Smudge Strength* property.

    Even when smudge is enabled brush still does its normal paint effect.
    If you want a purely smudging brush use zero alpha.
    It is also possible to have *Erase* option enabled together with smudge.
user: What is Placement and how is it used in Blender Python scripting?

assistant: There are a few methods to position the 3D Cursor.

### Direct Placement with the Mouse

[image reference removed]

Positioning the 3D Cursor with two orthogonal views.

The Cursor tool offers the most flexibility. Simply select it in the Toolbar
and click a point in the scene with `LMB` to place the 3D Cursor there.
In the tool settings, you can choose how it should be oriented:
by default, it matches the view orientation, but you can also make it
match the surface normal of a piece of geometry,
or the [transform orientation](controls/orientation.html).

Alternatively, you can press `Shift`-`RMB` with any tool selected.
In this case, the 3D Cursor will always be aligned to the view orientation.

For accuracy you should use two perpendicular orthogonal 3D Viewports,
i.e. any combination of top `Numpad7`, front `Numpad1` and side `Numpad3`.
That way you can control the positioning along two axes in one view and
determine the depth in the other.

By default, the depth of the geometry under the cursor is used.
This can be disabled using the *Cursor Surface Project* toggle
in the [Preferences](../preferences/editing.html).

### Sidebar

[image reference removed]

The 3D Cursor panel of the Sidebar region.

The 3D Cursor can also be positioned and oriented by editing the
respective values in the Sidebar.

### Snapping

One more way of positioning the 3D Cursor is through the Snap menu,
which allows you to move the Cursor to the origin of the selected object
for example.
user: Give a detailed overview of Mesh to SDF Grid Node: syntax, arguments, return values, common patterns.

assistant: # Mesh to SDF Grid Node

[image reference removed]

The *Mesh to SDF Grid* node converts a mesh into a Signed Distance Field (SDF)
grid. Each voxel in the resulting grid stores the shortest distance to the
surface of the mesh, with the sign indicating whether the voxel is inside or
outside the mesh.

Positive values represent distances outside the mesh, negative values represent
distances inside the mesh, and zero corresponds to the mesh surface.
SDF grids are useful for many applications, including surface reconstruction,
collision detection, morphing, and volumetric modeling.
user: Provide the full official documentation entry for Fmodifier Type Items, preserving all code examples.

assistant: # Fmodifier Type Items

NULL:
:   Invalid.

GENERATOR:
:   Generator.

    Generate a curve using a factorized or expanded polynomial.

FNGENERATOR:
:   Built-In Function.

    Generate a curve using standard math functions such as sin and cos.

ENVELOPE:
:   Envelope.

    Reshape F-Curve values, e.g. change amplitude of movements.

CYCLES:
:   Cycles.

    Cyclic extend/repeat keyframe sequence.

NOISE:
:   Noise.

    Add pseudo-random noise on top of F-Curves.

LIMITS:
:   Limits.

    Restrict maximum and minimum values of F-Curve.

STEPPED:
:   Stepped Interpolation.

    Snap values to nearest grid step, e.g. for a stop-motion look.
user: How do I use Virtual Machines in Blender? Include parameters, examples, warnings and best practices.

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

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

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

# Information

To find out which graphics card and driver Blender is using, use Help ‣ Save System Info inside
Blender. The OpenGL section will have information about your graphics card, vendor and driver version.
user: What is Subdivision and how is it used in Blender Python scripting?

assistant: # Subdivision

These settings are used to control [Adaptive Subdivision](../../../modeling/modifiers/generate/subdivision_surface.xhtml#modifiers-generate-subsurf-adaptive-subdivision).

Dicing Rate Render, Viewport
:   Multiplier for the size of [Micropolygons](../../../glossary/index.xhtml#term-Micropolygons) for the final/viewport render.

Offscreen Scale
:   Multiplier for dicing rate of geometry outside of the camera view.
    The dicing rate of objects is gradually increased the further they are outside the camera view.
    Lower values provide higher quality reflections and shadows for off screen objects,
    while higher values use less memory.

Max Subdivisions
:   Stop subdividing when this level is reached even if the dicing rate would produce finer [Tessellation](../../../glossary/index.xhtml#term-Tessellation).

Dicing Camera
:   Camera to use as reference point when subdividing geometry,
    useful to avoid crawling artifacts in animations when the scene camera is moving.
user: Give a detailed overview of Behavior: syntax, arguments, return values, common patterns.

assistant: When executed, this node evaluates the connected closure’s internal node graph.
All input values are passed into the closure by name, and all resulting values are returned through the corresponding
outputs.

If no closure is connected, or if the node is muted, *Evaluate Closure* automatically passes through any matching
inputs and outputs by name. This *pass-through mode* makes closures optional and allows node groups to function even
without one.

Evaluation occurs in the local context of the node tree where *Evaluate Closure* resides, inheriting relevant fields,
attributes, and geometry data.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: Application templates are a feature that allows you to define a re-usable configuration
that can be selected to replace the default configuration,
without requiring a separate Blender installation or overwriting your personal settings.

Application templates can be selected from the splash screen or File ‣ New submenu.
When there are no templates found the menu will not be displayed on the splash screen.

New application templates can be installed from the [Blender Menu](../interface/window_system/topbar.html#topbar-blender-menu).
If you would like to keep the current application template active on restarting Blender, save your preferences.

### Motivation

In some cases it’s not enough to write a single script or add-on,
and expect someone to replace their preferences and startup file, install scripts and change their keymap.

The goal of application templates is to support switching to a customized configuration
without disrupting your existing settings and installation.
This means people can build their own *applications* on top of Blender that can be easily distributed.

### Details

An application template may define its own:

Startup File
:   The default file to load with this template.

Preferences
:   Only certain preferences from a template are used:

    - Themes.
    - Add-ons.
    - Keymaps.
    - Viewport lighting.

Splash Screen
:   Templates may provide their own splash screen image.

Python Scripts
:   While templates have access to the same functionality as any other scripts,
    typical operations include:

    - Modifying and replacing parts of the user interface.
    - Defining new menus, keymaps and tools.
    - Defining a custom add-on path for template specific add-ons.

Templates also have their own user configuration, so saving a startup file while using a template
won’t overwrite your default startup file.

### Directory Layout

Templates may be located in one of two locations within the `scripts` directory.

Template locations:
:   `{BLENDER_USER_SCRIPTS}/startup/bl_app_templates_user`

    `{BLENDER_SYSTEM_SCRIPTS}/startup/bl_app_templates_system`

User configuration is stored in a subdirectory:

Without a template:
:   `./config/startup.blend`

    `./config/userpref.blend`

With a template:
:   `./config/{APP_TEMPLATE_ID}/startup.blend`

    `./config/{APP_TEMPLATE_ID}/userpref.blend`

See [Blender’s Directory Layout](blender_directory_layout.html#blender-directory-layout) for details on script and configuration locations.

### Command Line Access

Using the [command-line arguments](command_line/arguments.html#command-line-args) you can setup a launcher
that opens Blender with a specific app template:

```
blender --app-template my_template
```
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: ionState.html#bpy.types.XrSessionState.action_set_create "bpy.types.XrSessionState.action_set_create") - [`XrSessionState.action_state_get`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_state_get "bpy.types.XrSessionState.action_state_get") - [`XrSessionState.active_action_set_set`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.active_action_set_set "bpy.types.XrSessionState.active_action_set_set") - [`XrSessionState.controller_aim_location_get`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.controller_aim_location_get "bpy.types.XrSessionState.controller_aim_location_get") - [`XrSessionState.controller_aim_rotation_get`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.controller_aim_rotation_get "bpy.types.XrSessionState.controller_aim_rotation_get") - [`XrSessionState.controller_grip_location_get`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.controller_grip_location_get "bpy.types.XrSessionState.controller_grip_location_get") - [`XrSessionState.controller_grip_rotation_get`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.controller_grip_rotation_get "bpy.types.XrSessionState.controller_grip_rotation_get") - [`XrSessionState.controller_pose_actions_set`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.controller_pose_actions_set "bpy.types.XrSessionState.controller_pose_actions_set") - [`XrSessionState.haptic_action_apply`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.haptic_action_apply "bpy.types.XrSessionState.haptic_action_apply") - [`XrSessionState.haptic_action_stop`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.haptic_action_stop "bpy.types.XrSessionState.haptic_action_stop") - [`XrSessionState.is_running`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.is_running "bpy.types.XrSessionState.is_running") - [`XrSessionState.reset_to_base_pose`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.reset_to_base_pose "bpy.types.XrSessionState.reset_to_base_pose") |
user: How do I use Separate in Blender? Include parameters, examples, warnings and best practices.

assistant: Separates curve objects that are made of multiple distinct curves into their own objects.

Note, if there is only one curve in a Curve object,
This operation will create a new Curve object with no control points.
user: Describe Remesh from the Blender manual or Python API, including usage steps and snippets.

assistant: # Remesh

For a general explanation to remeshing, visit the [Introduction](../introduction/adaptive.xhtml).

Voxel Size `R`
:   The resolution or the amount of detail the remeshed mesh will have.
    The value is used to define the size, in object space, of the [Voxel](../../../glossary/index.xhtml#term-Voxel).
    These voxels are assembled around the mesh and are used to determine the new geometry.
    For example a value of 0.5m will create topological patches that are about 0.5m
    (assuming *Preserve Volume* is enabled).
    Lower values preserve finer details but will result in a mesh with a much more dense topology.

    The voxel size also be adjusted from the 3D Viewport using `R`.
    Using the shortcut displays an interactive grid overlay showing the resulting voxel size.
    Moving the mouse closer to center of the grid decreases the voxel size
    while moving away from the center increase the voxel size.
    Holding `Shift` increases the precision; adjusting the voxel size in small increments.

    Sample Voxel Size
    :   Used to adjust the *Voxel Size* by picking an area of the mesh
        to match the denseness of polygons after the remesh operation.

Adaptivity
:   Reduces the final face count by simplifying geometry where detail is not needed.
    This introduce triangulation to faces that do not need as much detail.
    Note, an *Adaptivity* value greater than zero disables *Fix Poles*.

Fix Poles
:   Tries to produce less [poles](../../../glossary/index.xhtml#term-Pole) at the cost of some performance to produce a better topological flow.

Preserve
:   Volume
    :   Tells the algorithm to try to preserve the original volume of the mesh.
        Enabling this could make the operator slower depending on the complexity of the mesh.

    Paint Mask
    :   Reprojects the [paint mask](../editing/mask.xhtml#sculpt-mask-menu) onto the new mesh.

    Face Sets
    :   Reprojects [Face Sets](../editing/face_sets.xhtml#sculpting-editing-facesets) onto the new mesh.

    Color Attributes
    :   Reprojects the [Color Attributes](../../../modeling/meshes/properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes) onto the
        new mesh.

Voxel Remesh
:   Performs the remeshing operation to create a new manifold mesh based on the volume of the current mesh.
    Performing this will lose all mesh object data layers associated with the original mesh.
user: Provide the full official documentation entry for UIPopover(bpy_struct), preserving all code examples.

assistant: # UIPopover(bpy_struct)

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

*class* bpy.types.UIPopover(*bpy_struct*)
:   layout
    :   Type:
        :   [`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (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: Explain Snap in complete detail according to the official Blender documentation.

assistant: [Mesh snapping](../../../editors/3dview/controls/snapping.html) 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: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Mean
:   The average value of all data.

Median
:   The median value of all data.

Sum
:   The sum value of all data.

Min
:   The min value of all data.

Max
:   The max value of all data.

Range
:   The difference between the max and min value.

Standard Deviation
:   How much values differ from the mean.
    A low standard deviation indicates that the values are grouped tightly together at the mean.
    A high standard deviation indicates that the values are spread out over a large range.

Variance
:   The variance of all data, defined as the square of the standard deviation.
user: How do I use Speaker(ID) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Speaker(ID)

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

*class* bpy.types.Speaker(*ID*)
:   Speaker data-block for 3D audio speaker objects

    animation_data
    :   Animation data for this data-block

        Type:
        :   [`AnimData`](bpy.types.AnimData.html#bpy.types.AnimData "bpy.types.AnimData"), (readonly)

    attenuation
    :   How strong the distance affects volume, depending on distance model

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

    cone_angle_inner
    :   Angle of the inner cone, in degrees, inside the cone the volume is 100%

        Type:
        :   float in [0, 360], default 360.0

    cone_angle_outer
    :   Angle of the outer cone, in degrees, outside this cone the volume is the outer cone volume, between inner and outer cone the volume is interpolated

        Type:
        :   float in [0, 360], default 360.0

    cone_volume_outer
    :   Volume outside the outer cone

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

    distance_max
    :   Maximum distance for volume calculation, no matter how far away the object is

        Type:
        :   float in [0, inf], default 3.40282e+38

    distance_reference
    :   Reference distance at which volume is 100%

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

    muted
    :   Mute the speaker

        Type:
        :   boolean, default False

    pitch
    :   Playback pitch of the sound

        Type:
        :   float in [0.1, 10], default 1.0

    sound
    :   Sound data-block used by this speaker

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

    volume
    :   How loud the sound is

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

    volume_max
    :   Maximum volume, no matter how near the object is

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

    volume_min
    :   Minimum volume, no matter how far away the object is

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # GeometryNodeFieldOnDomain(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.GeometryNodeFieldOnDomain(*GeometryNode*)
:   Retrieve values from a field on a different domain besides the domain from the context

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    domain
    :   Domain the field is evaluated in

        Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-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: Provide the full official documentation entry for Duplicate, preserving all code examples.

assistant: # Duplicate

This tool simply duplicates the selected elements,
without creating any connections with the rest of the mesh (unlike extrude, for example),
and places the duplicate at the location of the original. Once the duplication is done,
only the *new* duplicated elements are selected,
and you are automatically placed in move mode, so you can move your copy elsewhere…

In the *Toolbar* are settings for *Vector* offset, *Proportional Editing*,
*Duplication Mode*, and *Axis Constraints*.

Note that duplicated elements belong to the same
[vertex groups](../../properties/vertex_groups/index.xhtml) as the “original” ones.
The same goes for the [material indices](../../../../render/materials/assignment.xhtml#bi-multiple-materials),
the edge’s *Sharp* and *Seam* marks, and probably for the other vertex/edge/face properties…
user: What is Text Editor and how is it used in Blender Python scripting?

assistant: # Text Editor

This editor can be used to write Python scripts, Open Shading Language scripts,
or just plain text notes. To open it, you can switch to the *Scripting*
[workspace](../interface/window_system/workspaces.html) or press
`Shift`-`F11` to replace the current editor.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

A UV texture is a picture (image, sequence or movie)
that is used to color the surface of a mesh.
The UV texture is mapped to the mesh through one or more UV maps.
There are three ways to establish the image used by the UV texture:

1. Use any image editing program to create an image. In the Image Editor,
   select the UV texture and load the image. Blender will then use
   that texture’s UV map to transfer the colors to the faces of the mesh.
2. Paint a flat image in the Image Editor onto the currently selected UV texture,
   using its UV map to transfer the colors to the faces of the mesh.
3. Paint the mesh in the 3D Viewport, and let Blender use
   the currently selected UV map to update the UV texture
   (as discussed below).

Blender features a built-in paint mode called *Texture Paint* which is designed
specifically to help you edit your UV textures and images quickly and
easily in either the Image Editor or the 3D Viewport.
Since a UV texture is just a special-purpose image,
you can also use any external paint program, like GIMP or Krita.

[image reference removed]

Texture painting in Blender.

Since a mesh can have layers of UV textures, there may be many images that color the mesh.
However, each UV texture only has one image.

*Texture Paint* works in both a 3D Viewport and the Image Editor.
In the 3D Viewport in Texture Paint Mode, you paint directly on the mesh by projecting onto the UVs.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Threshold
:   How much changes in color affect the mask generation. A smaller threshold includes fewer similar colors.
    A larger threshold includes much more similar colors.

Contiguous
:   Mask only contiguous color areas. Colors that don’t touch the one that you click on will not be masked.

Invert
:   Invert the generated mask.

Preserve Previous Mask
:   Preserve previous mask and add or subtract the new one generated by the colors.
user: How do I use Quantize in Blender? Include parameters, examples, warnings and best practices.

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

[image reference removed]

Quantize example (Steps = 2).

Steps
:   The number of steps between 0 and 1 to quantize the weights into.
    For example 5 would allow the following weights `[0.0, 0.2, 0.4, 0.6, 0.8, 1.0]`.
user: Show practical ways to work with Settings in a Blender add-on or script – include code.

assistant: ### Surface

Sampling
:   Controls the sampling method for the world material. Selecting Auto or Manual enables
    *Multiple Importance Sampling* while None disables it. *Multiple Importance Sampling*
    is a method to sample the background texture such that lighter parts are favored,
    creating an importance map. It will produce less noise in the render in trade of artifacts ([Fireflies](../../glossary/index.xhtml#term-Fireflies)).
    Enable this when using an image texture with small area lights (like the sun),
    otherwise noise can take a long time to converge.

    Below is a comparison between *Multiple Importance Sample* off and on.
    Both images are rendered for 25 seconds (Off: 1,500 samples, On: 1,000 samples).

    |  |  |
    | --- | --- |
    | ../../_images/render_cycles_world-settings_mis-off.jpg   Multiple Importance Sample off. | ../../_images/render_cycles_world-settings_mis-on.jpg   Multiple Importance Sample on. |

Map Resolution
:   Sets the resolution of the importance map.
    A higher resolution will better detect small features in the map and give more accurate sampling
    but conversely will take up more memory and render slightly slower.
    Higher values also may produce less noise when using high-res images.

Max Bounces
:   Maximal number of bounces the background light will contribute to the render.

Shadow Caustics
:   Mark the World Shader as a refractive caustic caster. This setting can be used in conjunction with the
    [Cast and Receive caustics object settings](object_settings/object_data.xhtml#bpy-types-cyclesobjectsettings-is-caustics-caster)
    to selectively speed up refractive caustic rendering of select objects.

### Volume

Sampling Method
:   Distance:
    :   For dense volumes lit from far away *Distance* sampling is more efficient in most cases.
        Usually this shouldn’t be used for World volumes.

    Equiangular:
    :   If you have got a light inside or near the volume then *equiangular* sampling is better.

    Multiple Importance:
    :   If you have a combination of both, then the multiple importance sampling will be better.

Interpolation
:   Interpolation method to use for the volume.

    Linear:
    :   Simple interpolation which gives good results for thin volumes.

    Cubic:
    :   Smoothed high-quality interpolation needed for more dense volumes, but slower.

Step Size Biased
:   Distance between volume shader samples for world volume shaders.
    Only enabled when Render ‣ Volumes ‣ Biased is enabled.
    See [Volume Render Settings](render_settings/volumes.xhtml) for more information.

### Light Group

Light Group Cycles only
:   Select the [Light Group](../layers/passes.xhtml#bpy-types-viewlayer-active-lightgroup-index) to add the
    current *World Surface Shader* too.

    Add Light Group
    :   If the name input into the *Light Group* field does not align with an existing
        Light Group, then pressing this button will create a *Light Group* with that name
        and assign this *World Shader* to it.
user: Provide the full official documentation entry for AssetLibraryReference(bpy_struct), preserving all code examples.

assistant: # AssetLibraryReference(bpy_struct)

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

*class* bpy.types.AssetLibraryReference(*bpy_struct*)
:   Identifier to refer to the asset library

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

assistant: ### Shadow Terminator

Geometry Offset
:   Offset rays from the surface to reduce shadow terminator artifacts on low-poly geometry.
    Higher values affect more triangles, a value of one affecting all triangles and zero having no effect.
    The default value only affects triangles at grazing angles to light and should eliminate most artifacts.

    Unlike the *Shading Offset*, this option has little affect on the lighting
    making it the preferable method to handle shadow terminator artifacts.

Shading Offset
:   Pushes the shadow terminator (the line that divides the light and dark) towards the light
    to hide artifacts on low-poly geometry such as the ones below:

    |  |  |
    | --- | --- |
    | ../../../_images/render_cycles_object-settings_object-data_shading-terminator1.jpg   Shadow Terminator Artifacts. | ../../../_images/render_cycles_object-settings_object-data_shading-terminator2.jpg   Result of using an offset of 0.15. |

### Fast GI Approximation

AO Distance
:   Override for the world’s [AO Distance](../render_settings/light_paths.html#bpy-types-cyclesrendersettings-use-fast-gi),
    if the value is zero the world’s distance is used.

### Caustics

Mark objects as caustic casters or receivers. This is used in conjunction with a
[Light](../light_settings.html#bpy-types-cycleslightsettings-is-caustics-light) or
[World Shader](../world_settings.html#bpy-types-cyclesworldsettings-is-caustics-light) with *Shadow Caustics* enabled
to selectively speed up caustic rendering of objects in your scene.

Cast Shadow Caustics
:   Mark an object as a caustic caster.

Receive Shadow Caustics
:   Mark an object as a caustic receiver.

|  |  |
| --- | --- |
| ../../../_images/render_cycles_object-settings_caustics-example1.png   Rendering caustics inside an eye without MNEE at 32 samples per pixel. | ../../../_images/render_cycles_object-settings_caustics-example2.png   Rendering caustics inside an eye using MNEE at 32 samples per pixel. |

### Light Group

Light Group
:   Select the [Light Group](../../layers/passes.html#bpy-types-viewlayer-active-lightgroup-index) to add the
    current *Object* or *Light* too.

    Add Light Group
    :   If the name input into the *Light Group* field does not align with an existing
        Light Group, then pressing this button will create a *Light Group* with that name
        and assign the selected *Object* or *Light* to it.

### Light Linking

Limit light influence to specified objects, with [Light Linking](../../lights/light_linking.html#bpy-types-object-light-linking).

Receiver Collection
:   Collection of objects that will receive light emitted from the object.

### Shadow Linking

Limit shadows to specified objects, with [Light Linking](../../lights/light_linking.html#bpy-types-object-light-linking).

Shadow Blocker Collection
:   Collection of objects that will act as shadow blockers for light emitted from the object.
user: How do I use Fields in Blender? Include parameters, examples, warnings and best practices.

assistant: # Fields

Fundamentally, a field is a function: a set of instructions that can transform an arbitrary number
of inputs into a single output. A field’s result can then be calculated many times with different input data.
They are used all over geometry nodes to allow calculations that have different results
for every element (mesh vertices, faces, etc.).

[image reference removed]

A field input to a node.

For example, in the figure above, the field connected to the “Set Position” node
depends on two inputs, [Position](geometry/read/position.xhtml) and
[Index](geometry/read/input_index.xhtml), and transforms them into
a vector using a single instruction.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Strength
:   Light strength before applying falloff modification.

Smooth
:   Smooth intensity of light near light sources. This can avoid harsh highlights,
    and reduce global illumination noise. 0.0 corresponds to no smoothing; higher values smooth more.
    The maximum light strength will be strength/smooth.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.line_style`](bpy.context.html#bpy.context.line_style "bpy.context.line_style") - [`BlendData.linestyles`](bpy.types.BlendData.html#bpy.types.BlendData.linestyles "bpy.types.BlendData.linestyles") - [`BlendDataLineStyles.new`](bpy.types.BlendDataLineStyles.html#bpy.types.BlendDataLineStyles.new "bpy.types.BlendDataLineStyles.new") | - [`BlendDataLineStyles.remove`](bpy.types.BlendDataLineStyles.html#bpy.types.BlendDataLineStyles.remove "bpy.types.BlendDataLineStyles.remove") - [`FreestyleLineSet.linestyle`](bpy.types.FreestyleLineSet.html#bpy.types.FreestyleLineSet.linestyle "bpy.types.FreestyleLineSet.linestyle") |