PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Clean in complete detail according to the official Blender documentation.

assistant: Clean Vertex Group Weights unassigns vertices from
[Vertex Groups](../../modeling/meshes/properties/vertex_groups/index.html)
whose weights are below the *Limit*. Removes weights below a given threshold.
This tool is useful for clearing your weight groups of very low (or zero) weights.

In the example shown, a cutoff value of 0.2 is used (see operator options below)
so all blue parts are cleaned out.

Note, the images use the *Show Zero weights* Active option
so that unreferenced Weights are shown in Black.

[image reference removed]

Clean example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   This is the minimum weight value that will be kept in the group.
    Weights below this value will be removed from the group.

Keep Single
:   Ensure that the *Clean* tool will not create completely unreferenced vertices
    (vertices which are not assigned to any vertex group), so each vertex will
    keep at least one weight, even if it is below the limit value!
user: Show practical ways to work with FunctionNodeSeparateColor(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeSeparateColor(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.FunctionNodeSeparateColor(*FunctionNode*)
:   Split a color into separate channels, based on a particular color model

    mode
    :   Mode of color processing

        Type:
        :   enum in [Node Combsep Color Items](bpy_types_enum_items/node_combsep_color_items.html#rna-enum-node-combsep-color-items), default `'RGB'`

    *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 Images, preserving all code examples.

assistant: Use the figure directive for embedding images with captions:

```
.. figure:: /images/interface_splash_current.webp

   Splash screen of Blender.
```

### Screenshots Guidelines

To ensure consistency across screenshots:

1. Use Blender’s default theme and settings.
2. Zoom to the maximum level (`Ctrl`-`MMB` or `NumpadPlus`).
3. Zoom out exactly eight steps (`NumpadMinus`, pressed eight times).
4. Leave around a 30-pixel margin around the content, if applicable.

### File Naming

Follow these guidelines for naming image files:

- Use lowercase letters, no spaces, underscores between sections, and dashes within multi-word sections.
- Place images only in the `manual/images` directory (no subfolders).

Examples:

- `interface_splash_current.png`
- `modeling_meshes_edit-mode.png`

### Image Formats

- `.png`: For interface screenshots or solid-color images.
- `.jpg`: For photographic images or renders with high color variation.
- Avoid `.gif`; use embedded videos for animations instead.
user: Explain Generic Constraint in complete detail according to the official Blender documentation.

assistant: # Generic Constraint

The generic constraint has a lot of available parameters.

The X, Y, and Z axis constraints can be used to limit the amount of translation between the objects.
Clamping the min/max to zero has the same effect as the Point constraint.

Clamping the relative rotation to zero keeps the objects in alignment.
Combining an absolute rotation and translation clamp would behave much like the Fixed constraint.

Using a nonzero spread on any parameter allows it to oscillate
in that range throughout the course of the simulation.
user: Describe Default Workspaces from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender’s default startup shows the “Layout” workspace in the main area.
This workspace is a general workspace to preview your scene
and contains the following Editors:

- [3D Viewport](../../editors/3dview/introduction.html) on top left.
- [Outliner](../../editors/outliner/introduction.html) on top right.
- [Properties](../../editors/properties_editor.html) on bottom right.
- [Dopesheet](../../editors/dope_sheet/index.html) on bottom left.

[image reference removed]

Blender’s ‘Layout’ Workspace with four editors.

3D Viewport (yellow), Outliner (green), Properties (blue) and Timeline (red).

Blender also has several other workspaces added by default:

Modeling:
:   For modification of geometry by modeling tools.

Sculpting:
:   For modification of meshes by sculpting tools.

UV Editing:
:   For mapping of image texture coordinates to 3D surfaces.

Texture Paint:
:   For coloring image textures in the 3D Viewport.

Shading:
:   For specifying material properties for rendering.

Animation:
:   For making properties of objects dependent on time.

Rendering:
:   For viewing and analyzing rendering results.

Compositing:
:   For combining and post-processing of images and rendering information.

Geometry Nodes:
:   For procedural modeling using [Geometry Nodes](../../modeling/geometry_nodes/index.html).

Scripting:
:   For interacting with Blender’s Python API and writing scripts.

### Additional Workspaces

Blender has a couple additional Workspaces to choose from when adding a new Workspace:

2D Animation

2D Animation:
:   General workspace to work with Grease Pencil.

2D Full Canvas:
:   Similar to “2D Animation” but contains a larger canvas.

VFX

Masking:
:   For creating 2D masks for compositing or video editing.

Motion Tracking:
:   For calculating camera motion and stabilizing video footage.

Video Editing

Video Editing:
:   For sequencing together media into one video.
user: Show practical ways to work with Normal Map Node in a Blender add-on or script – include code.

assistant: # Normal Map Node

[image reference removed]

The *Normal Map* node generates a perturbed normal from an RGB normal map image.
This is usually chained with an *Image Texture* node in the color input,
to specify the normal map image. For tangent space normal maps,
the UV coordinates for the image must match,
and the image texture should be set to *Non-Color* mode to give correct results.
user: Provide the full official documentation entry for Header, preserving all code examples.

assistant: The *Header* contains various menus, buttons and options, partially based on the current node tree type.

[image reference removed]

Common node editor header options.

View
:   This menu changes your view of the editor.

Select
:   This menu allows you to select a node or groups of nodes.

Add
:   This menu allows you to add nodes.

Node
:   This menu allows you to do things with selected nodes.

Pinned
:   When enabled, the editor always displays the currently selected node tree,
    regardless of changes in the active object or scene.
    This allows you to edit a material, texture, or compositor node tree independently
    of what is selected in the 3D Viewport or which scene is active.
    Useful when working across multiple objects or scenes but wanting to keep the editor
    focused on one specific node tree.

Parent Node Tree
:   Leaves the current [node group](groups.xhtml) and returns to the parent node group/tree.

Snapping
:   Change options for snapping node positions to achieve a cleaner node tree layout.
    See [Arranging Nodes](arranging.xhtml).
user: Give a detailed overview of Installing Extensions: syntax, arguments, return values, common patterns.

assistant: There are different ways to install an extension:

Install from the Website
:   Drag the installation URL into Blender.

Install from Blender
:   Search for the extension name and click on Install.

[Install from Disk](#bpy-ops-extensions-package-install-files)
:   Use the drop-down menu in the top right,
    or drag-and-drop an extension `.zip` package into Blender.
user: Describe Can I redraw during script execution? from the Blender manual or Python API, including usage steps and snippets.

assistant: The official answer to this is no, or… *“You don’t want to do that”*.
To give some background on the topic:

While a script executes, Blender waits for it to finish and is effectively locked until it’s done;
while in this state Blender won’t redraw or respond to user input.
Normally this is not such a problem because scripts distributed with Blender
tend not to run for an extended period of time,
nevertheless scripts *can* take a long time to complete and it would be nice to see progress in the viewport.

Tools that lock Blender in a loop redraw are highly discouraged
since they conflict with Blender’s ability to run multiple operators
at once and update different parts of the interface as the tool runs.

So the solution here is to write a **modal** operator, which is an operator that defines a `modal()` function,
See the modal operator template in the text editor.
Modal operators execute on user input or setup their own timers to run frequently,
they can handle the events or pass through to be handled by the keymap or other modal operators.
Examples of modal operators are Transform, Painting, Fly Navigation and File Select.

Writing modal operators takes more effort than a simple `for` loop
that contains draw calls but is more flexible and integrates better with Blender’s design.

Ok, Ok! I still want to draw from Python

If you insist – yes it’s possible, but scripts that use this hack will not be considered
for inclusion in Blender and any issue with using it will not be considered a bug,
there is also no guaranteed compatibility in future releases.

```
bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
```
user: What is Socket Syncing and how is it used in Blender Python scripting?

assistant: Bundles use socket names to match their inputs and outputs.
If two bundle nodes are connected but have mismatched signatures,
Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never updated automatically to avoid overwriting data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Provide the full official documentation entry for Track To Constraint, preserving all code examples.

assistant: # Track To Constraint

The *Track To* constraint makes an object or bone point towards a certain target,
then roll to make a certain local axis point upwards.
It’s typically called “Look At” or “Aim” in other 3D software.

If the constraint owner is almost directly above the target, the roll around
the tracking axis will become unstable. For this scenario, it’s recommended to
use the [Damped Track Constraint](damped_track.html) instead.
user: Show practical ways to work with Interface in a Blender add-on or script – include code.

assistant: ### Header

Node Tree
:   Chooses which node group (compositor node tree) to display and edit.
    Each [Scene](../scene_layout/scene/index.xhtml) can have its own compositor node tree.
    You can also create and switch to custom node groups for reuse.

Pinned
:   When enabled, the editor always displays the selected node tree, regardless of the active scene.
    This is useful when working with multiple scenes but wanting to keep the compositor focused on one node tree.

#### Gizmos

Controls the display of gizmos in the Compositor.

Clicking  (Show Gizmos) toggles all gizmos in the Compositor
The drop-down button displays a popover with more detailed settings,
which are described below.

Viewport Gizmos

Active Node
:   Display a context-sensitive gizmo for the currently selected node.
    This may include transform controls or other visual aids depending on the node type.

### Asset Shelf

The *Asset Shelf* provides quick access to compositor node assets, allowing users to drag and drop
predefined node setups directly into the compositor workspace.
Any node group marked as an asset will appear here automatically.

Located at the bottom of the editor, the shelf offers a compact and easily accessible interface for
inserting and organizing compositor assets. Compared to the
[Asset Browser](asset_browser.xhtml), it integrates more seamlessly into the
compositing workflow and can be shown or hidden as needed.

The Asset Shelf helps users:

- Quickly build node setups using reusable assets.
- Explore common compositing techniques and effects.
- Work entirely within Blender for post-processing.

The Asset Shelf can be toggled on or off from the compositor editor’s header.
user: Give a detailed overview of GpSculptPaint(Paint): syntax, arguments, return values, common patterns.

assistant: # GpSculptPaint(Paint)

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

*class* bpy.types.GpSculptPaint(*Paint*)
:   *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 Cloth Modifier in complete detail according to the official Blender documentation.

assistant: # Cloth Modifier

The Cloth modifier is a container for a [Cloth Physics](../../../physics/cloth/index.html) simulation. It can be useful
for example, to simulate on a low-poly mesh then add a [Subdivision Surface Modifier](../generate/subdivision_surface.html)
after the Cloth modifier to improve the visual quality of the cloth without drastically increasing simulation times.
user: How do I use Light Type Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Light Type Items

POINT:
:   Point.

    Omnidirectional point light source.

SUN:
:   Sun.

    Constant direction parallel ray light source.

SPOT:
:   Spot.

    Directional cone light source.

AREA:
:   Area.

    Directional area light source.
user: How do I use Roll in Blender? Include parameters, examples, warnings and best practices.

assistant: Activating the [Axes](../properties/display.xhtml#bpy-types-armature-show-axes)
checkbox will show local axes for each bone’s tip. The Y axis is always aligned along the bone,
oriented from root to tip, this is the “roll” axis of the bones.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Tip Selection
:   A boolean selection that is true only for the tip points of curves.
    This can be used to isolate operations that affect only the curve ends.

Tip Position
:   The position of each curve’s tip point in 3D space.
    Useful for determining the end location of curves, placing instances, or measuring curve length.

Tip Direction
:   A normalized vector representing the direction of the final segment of each curve,
    pointing toward the tip.
    This can be used for orienting instances or controlling effects based on curve direction.

Tip Index
:   The index of the tip point for each curve.
    This corresponds to the last point in the curve’s point list.
user: Explain Bounding Box Node in complete detail according to the official Blender documentation.

assistant: # Bounding Box Node

[image reference removed]

The *Bounding Box* node creates a box mesh with the minimum volume that encapsulates
the geometry of the input. The node also can output the vector positions of the bounding dimensions.

The mesh output and the *Min* and *Max* outputs do not take instances into account. Instead,
for instanced geometry, a bounding box is computed for each instance rather than the whole geometry.
To compute the bounding box including the instances,
a [Realize Instances Node](../../instances/realize_instances.xhtml) can be used.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

Noise Texture with high detail.

Different Noise types with the same parameters.

|  |  |
| --- | --- |
| <../../../_images/render_shader-nodes_textures_musgrave_example-type-fbm.jpg>   fBM (fractal Brownian Motion). | <../../../_images/render_shader-nodes_textures_musgrave_example-type-multifractal.jpg>   Multifractal. |
| <../../../_images/render_shader-nodes_textures_musgrave_example-type-hybrid.jpg>   Hybrid Multifractal. | <../../../_images/render_shader-nodes_textures_musgrave_example-type-terrain.jpg>   Heterogeneous Terrain. |
| <../../../_images/render_shader-nodes_textures_musgrave_example-type-ridged.jpg>   Ridged Multifractal. |  |
user: What is PreferencesExtensions(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PreferencesExtensions(bpy_struct)

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

*class* bpy.types.PreferencesExtensions(*bpy_struct*)
:   Settings for extensions

    active_repo
    :   Index of the extensions repository being edited in the Preferences UI

        Type:
        :   int in [-32768, 32767], default 0

    repos
    :   Type:
        :   [`UserExtensionRepoCollection`](bpy.types.UserExtensionRepoCollection.html#bpy.types.UserExtensionRepoCollection "bpy.types.UserExtensionRepoCollection") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`UserExtensionRepo`](bpy.types.UserExtensionRepo.html#bpy.types.UserExtensionRepo "bpy.types.UserExtensionRepo"), (readonly)

    use_online_access_handled
    :   The user has been shown the “Online Access” prompt and made a choice

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Fileselect Params Sort Items, preserving all code examples.

assistant: # Fileselect Params Sort Items

FILE_SORT_ALPHA:
:   Name.

    Sort the file list alphabetically.

FILE_SORT_EXTENSION:
:   Extension.

    Sort the file list by extension/type.

FILE_SORT_TIME:
:   Modified Date.

    Sort files by modification time.

FILE_SORT_SIZE:
:   Size.

    Sort files by size.

ASSET_CATALOG:
:   Asset Catalog.

    Sort the asset list so that assets in the same catalog are kept together. Within a single catalog, assets are ordered by name. The catalogs are in order of the flattened catalog hierarchy..
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

In addition to modeling and animation, Blender can be used to edit videos.
There are two possible methods for this, one being the [Compositor](../compositing/introduction.xhtml)
and the other, described in this chapter, being the Video Sequencer.
The Video Sequencer within Blender is a complete video editing system that allows you to combine multiple
video channels and add effects to them. You can use these effects to create powerful video edits,
especially when you combine it with the animation power of Blender!

To use the Video Sequencer, you load multiple video clips and lay them end-to-end (or in some cases, overlay them),
inserting fades and transitions to link the end of one clip to the beginning of another.
Finally, you can add audio and synchronize the timing of the video sequence to match it.

[image reference removed]

Default Video Editing screen layout.
user: What is Alpha Under and how is it used in Blender Python scripting?

assistant: With *Alpha Under*, this is the contrary:
The first strip selected is the foreground, and the second one, the background.
Moreover, the *Opacity* controls the transparency of the *background*, i.e. an *Opacity* of 0.0;
will only show the foreground (the background is completely transparent),
and an *Opacity* of 1.0 will give the same results as with *Alpha Over*.
user: What is Transform and how is it used in Blender Python scripting?

assistant: Move `G`
:   Move the selected strips in time or to a different track.

Extend `E`
:   Lets you quickly move the selected strips that are on a certain side of the Playhead.
    This is handy if you need to, say, move all the strips after a certain time point to
    the right to make space for new ones.

    To use this operator, first select some or all strips and place your mouse cursor to
    the left or right of the Playhead. Then, press `E`, move the mouse to move (only)
    the strips on that side of the Playhead, and press `LMB` to confirm
    (or `RMB` to cancel).

    If a strip straddles the Playhead, only its starting/ending point will be moved
    (again depending on the position of the mouse cursor).

Scale `S`
:   Scales the selected strips, using the Playhead as the pivot point.

### Swap

Swap the order of the selected strips in their track.

### Move Up

Move selected strips up a track if there is room.

### Move Down

Move selected strips down a track if there is room.
user: What is Preset Management and how is it used in Blender Python scripting?

assistant: Theme Presets
:   Select the Theme from a list of predefined Themes.

Add Theme
:   Adds a custom theme to the preset list.

Remove Theme
:   Removes a custom theme from the preset list.

Save Theme
:   Save a custom theme in the preset list.

    This will save the theme to an XML file in the `./scripts/presets/interface_theme/` subdirectory of one of
    the [configuration directories](../../advanced/blender_directory_layout.html).

Install
:   Load and apply a Blender XML theme file and add it to the list of theme presets.

Reset
:   Reset to the default theme colors.

Blender comes bundled with a small selection of themes.

[image reference removed]

This is an example of the theme *Blender Light*.
user: Show practical ways to work with The Source of the Noise in a Blender add-on or script – include code.

assistant: To understand where noise can come from, take for example the scene below.
When we trace a light ray into the location marked by the white circle on a red dot,
the second image below gives an impression of what the diffuse shader “sees”.

To find the light that is reflected from this surface,
we need to find the average color from all these pixels.
Note the glossy highlight on the sphere,
and the bright spot the light casts on the nearby wall. These hot-spots are much brighter than
other parts of the image and will contribute significantly to the lighting of this pixel.

|  |  |  |
| --- | --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_fisheye-reference.jpg   The scene. | ../../../_images/render_cycles_optimizations_reducing-noise_fisheye.jpg   Irradiance at the shading point. | ../../../_images/render_cycles_optimizations_reducing-noise_fisheye-hotspot.jpg   The detected highlights. |

The light is a known light source, so its location is already known,
but the glossy highlight(s) that it causes are a different matter.
The best we can do with path tracing is to distribute light rays randomly over the hemisphere,
hoping to find all the important bright spots. If for some pixels we miss some bright spot,
but we do find it for another, that results in noise. The more samples we take,
the higher the probability that we cover all the important sources of light.

With some tricks we can reduce this noise. If we blur the bright spots,
they become bigger and less intense, making them easier to find and less noisy.
This will not give the same exact result,
but often it’s close enough when viewed through a diffuse or soft glossy reflection.
Below is an example of using [Glossy Filter](../render_settings/light_paths.xhtml#bpy-types-cyclesrendersettings-blur-glossy)
and [Light Falloff](../../shader_nodes/color/light_falloff.xhtml).

|  |  |  |
| --- | --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_fisheye-blur-reference.jpg   Using Glossy Filter & Light Falloff. | ../../../_images/render_cycles_optimizations_reducing-noise_fisheye-blur.jpg   Irradiance at the shading point. | ../../../_images/render_cycles_optimizations_reducing-noise_fisheye-blur-hotspot.jpg   The detected highlights. |
user: How do I use Misc in Blender? Include parameters, examples, warnings and best practices.

assistant: Banking
:   Amount of rotation around velocity vector on turns. Banking of 1.0 gives a natural banking effect.

Pitch
:   Amount of rotation around side vector.

Height
:   Boid height relative to particle size.
user: Give a detailed overview of Context Mode Items: syntax, arguments, return values, common patterns.

assistant: # Context Mode Items

EDIT_MESH:
:   Mesh Edit.

EDIT_CURVE:
:   Curve Edit.

EDIT_CURVES:
:   Curves Edit.

EDIT_SURFACE:
:   Surface Edit.

EDIT_TEXT:
:   Text Edit.

EDIT_ARMATURE:
:   Armature Edit.

EDIT_METABALL:
:   Metaball Edit.

EDIT_LATTICE:
:   Lattice Edit.

EDIT_GREASE_PENCIL:
:   Grease Pencil Edit.

EDIT_POINTCLOUD:
:   Point Cloud Edit.

POSE:
:   Pose.

SCULPT:
:   Sculpt.

PAINT_WEIGHT:
:   Weight Paint.

PAINT_VERTEX:
:   Vertex Paint.

PAINT_TEXTURE:
:   Texture Paint.

PARTICLE:
:   Particle.

OBJECT:
:   Object.

PAINT_GPENCIL:
:   Grease Pencil Paint.

EDIT_GPENCIL:
:   Grease Pencil Edit.

SCULPT_GPENCIL:
:   Grease Pencil Sculpt.

WEIGHT_GPENCIL:
:   Grease Pencil Weight Paint.

VERTEX_GPENCIL:
:   Grease Pencil Vertex Paint.

SCULPT_CURVES:
:   Curves Sculpt.

PAINT_GREASE_PENCIL:
:   Grease Pencil Paint.

SCULPT_GREASE_PENCIL:
:   Grease Pencil Sculpt.

WEIGHT_GREASE_PENCIL:
:   Grease Pencil Weight Paint.

VERTEX_GREASE_PENCIL:
:   Grease Pencil Vertex Paint.
user: Describe Bake Pass Filter Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Bake Pass Filter Type Items

NONE:
:   None.

EMIT:
:   Emit.

DIRECT:
:   Direct.

INDIRECT:
:   Indirect.

COLOR:
:   Color.

DIFFUSE:
:   Diffuse.

GLOSSY:
:   Glossy.

TRANSMISSION:
:   Transmission.
user: Give a detailed overview of Setting up the Build Environment: syntax, arguments, return values, common patterns.

assistant: - Open a Terminal window.
- Enter the `blender-manual` folder which was just added by `git clone`:

  ```
  cd C:\blender-manual
  ```
- Install dependencies:

  ```
  make setup
  ```
- If all goes well, you should see the following message when it is finished:

  ```
  Successfully installed Jinja2 MarkupSafe Pygments Sphinx docutils sphinx-rtd-theme Cleaning up...
  ```

During setup, some warnings may be shown, but do not worry about them. However, if any errors occur, they may cause
some problems.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Threshold
:   Areas brighter than the *Threshold* are blurred.

Clamp
:   The maximum luminosity that is added.

Boost Factor
:   Multiplier of the brightness.

Blur Distance
:   The size of the blur.

Quality
:   Improves the quality of the glow by giving smoother results but will be slower.

Only Boost
:   This checkbox allows you to only show/use
    the “modified” version of the image, without the base one.
user: What is Open Cached Render and how is it used in Blender Python scripting?

assistant: Find the render cache file for the current scene and load it into the
Render Result. This way, you can restore the last render from a previous
Blender session and continue working in the Compositor without having to
render the scene again.

Note that Blender doesn’t create these cache files by default. You
have to enable [Cache Result](../../render/output/properties/output.xhtml#bpy-types-rendersettings-use-render-cache)
in the scene’s Output options and then render it at least once.
user: Describe The Home Location of Assets from the Blender manual or Python API, including usage steps and snippets.

assistant: There can be as many catalogs as you want, but **an asset can be assigned to a single catalog** at a time.
This is similar to a file system, where a file is only in one directory
(ignoring advanced things like symbolic links).

Catalogs themselves can be nested and moved by dragging and dropping.
Moving a catalog will not modify the assets it contains; they will simply move along
to the new location of the catalog.

Selecting a catalog in the Asset Browser will show all assets in that catalog and in child catalogs.
So, in the preceding example, selecting `Characters/Ellie/Poses` will also show assets from
`Characters/Ellie/Poses/Head` and `Characters/Ellie/Poses/Hands`.
user: Give a detailed overview of Extrude: syntax, arguments, return values, common patterns.

assistant: # Extrude

When you press `E`, for each selected tip
(either explicitly or implicitly), a new bone is created.
This bone will be the child of “its” tip owner, and connected to it. As usual,
once extrusion is done, only the new bones’ tips are selected, and in select mode,
so you can place them to your liking. See Fig. [Extrusion example.](#fig-rig-bones-extrusion).

Extrusion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_extrude_example-1.png   An armature with three selected tips. | ../../../../_images/animation_armatures_bones_editing_extrude_example-2.png   The three extruded bones. |

You also can use the rotating/scaling extrusions,
as with meshes, by pressing respectively `E` `R` and `E` `S` –
as well as [locked](../../../../scene_layout/object/editing/transform/control/axis_locking.xhtml)
extrusion along a global or local axis.

Mirror extrusion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_extrude_mirror-1.png   A single selected bone’s tip. | ../../../../_images/animation_armatures_bones_editing_extrude_mirror-2.png   The two mirror-extruded bones. |

Bones have an extra “mirror extruding” tool, called by pressing `Shift`-`E`.
By default, it behaves exactly like the standard extrusion.
But once you have enabled [X-Axis Mirror](../tools/tool_settings.xhtml#bpy-types-armature-use-mirror-x) editing option,
each extruded tip will produce *two new bones*, having the same name except for the “_L”/ “_R” suffix
(for left/right, see the [naming conventions](naming.xhtml#armature-editing-naming-conventions)).
The “_L” bone behaves like the single one produced by the default extrusion –
you can move, rotate or scale it exactly the same way.
The “_R” bone is its mirror counterpart (along the armature’s local X axis),
see Fig. [Mirror extrusion example.](#fig-rig-bone-mirror).

In case you are wondering, you cannot just press `X` to solve this as you would in mesh editing,
because extrusion selects the newly created tips, and as explained below the Delete tool ignores bones’ joints.
To get rid of these extruded bones without undoing, you would have to move the tips,
then select the bones and [delete](delete.xhtml#bpy-ops-armature-delete) them.
user: Provide the full official documentation entry for Mesh Boolean Node, preserving all code examples.

assistant: # Mesh Boolean Node

[image reference removed]

The *Mesh Boolean Node* allows you to cut, subtract, and join the geometry of two inputs.
This node offers the same operations as the [Boolean modifier](../../../modifiers/generate/booleans.xhtml).
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_glass_example.jpg   Sharp Glass example. | <../../../_images/render_shader-nodes_shader_glass_behavior-sharp.svg>   Sharp Glass behavior. |
| ../../../_images/render_shader-nodes_shader_glass_example-rough.jpg   Rough Glass example. | <../../../_images/render_shader-nodes_shader_glass_behavior.svg>   Rough Glass behavior. |
user: Explain Tool Settings in complete detail according to the official Blender documentation.

assistant: Number of Cuts
:   Increases and decreases the number of cuts to create.
    These cuts are uniformly distributed in the original face loop,
    and you will *not* be able to control their positions.

Correct UVs
:   Corrects the corresponding UV coordinates, if these exist, to avoid image distortions.
user: Give a detailed overview of FunctionNodeSeparateColor(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeSeparateColor(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.FunctionNodeSeparateColor(*FunctionNode*)
:   Split a color into separate channels, based on a particular color model

    mode
    :   Mode of color processing

        Type:
        :   enum in [Node Combsep Color Items](bpy_types_enum_items/node_combsep_color_items.html#rna-enum-node-combsep-color-items), default `'RGB'`

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

assistant: Denoising can be enabled to reduce the amount of noise from the raw ray-traced output.
This can help image stability but will also over-blur the final ray-traced output.

Spatial Reuse
:   Reuse the rays from neighbor pixels.
    Can introduce some light leaks across surfaces.

Temporal Accumulation
:   Accumulate samples by re-projecting the last ray tracing results.
    This removes [Fireflies](../../../glossary/index.html#term-Fireflies) but also introduces color bias.
    Useful for viewport temporal stability or making renders converge faster.

Bilateral Filter
:   Blur the resolved ray-traced output using a bilateral filter.
user: Show practical ways to work with Modeling Modes in a Blender add-on or script – include code.

assistant: The 3D Viewport has three principal modes that allow for the creation,
editing and manipulation of the mesh models.
Each of the three modes has a variety of tools. Some tools may be found in one or more of the modes.

Modes that used for modeling:

Object Mode
:   Supports basic operations such as object creation,
    joining objects, managing shape keys, UV/color layers.

Edit Mode
:   Used for the majority of mesh editing operations.

Sculpt Mode
:   Instead of dealing with individual mesh elements,
    supports sculpting with brushes *(not covered in this chapter)*.
user: Explain Supported Modes & Object Types in complete detail according to the official Blender documentation.

assistant: Node groups must specify which modes and object types they support.
This can be configured using the popover menus in the header of the
[Geometry Node Editor](../../editors/geometry_node.html#editors-geometry-nodes-tool-context).
user: Describe TextureNodeDistance(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeDistance(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.TextureNodeDistance(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`NodeEvaluateClosure.output_items`](bpy.types.NodeEvaluateClosure.html#bpy.types.NodeEvaluateClosure.output_items "bpy.types.NodeEvaluateClosure.output_items") - [`NodeEvaluateClosureOutputItems.new`](bpy.types.NodeEvaluateClosureOutputItems.html#bpy.types.NodeEvaluateClosureOutputItems.new "bpy.types.NodeEvaluateClosureOutputItems.new") | - [`NodeEvaluateClosureOutputItems.remove`](bpy.types.NodeEvaluateClosureOutputItems.html#bpy.types.NodeEvaluateClosureOutputItems.remove "bpy.types.NodeEvaluateClosureOutputItems.remove") |
user: Describe FunctionNodeInvertRotation(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeInvertRotation(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.FunctionNodeInvertRotation(*FunctionNode*)
:   Compute the inverse of the given rotation

    *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: What is wmOwnerID(bpy_struct) and how is it used in Blender Python scripting?

assistant: # wmOwnerID(bpy_struct)

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

*class* bpy.types.wmOwnerID(*bpy_struct*)
:   name
    :   Type:
        :   string, default “”, (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: Provide the full official documentation entry for StretchToConstraint(Constraint), preserving all code examples.

assistant: # StretchToConstraint(Constraint)

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

*class* bpy.types.StretchToConstraint(*Constraint*)
:   Stretch to meet the target object

    bulge
    :   Factor between volume variation and stretching

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

    bulge_max
    :   Maximum volume stretching factor

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

    bulge_min
    :   Minimum volume stretching factor

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

    bulge_smooth
    :   Strength of volume stretching clamping

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

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    keep_axis
    :   The rotation type and axis order to use

        - `PLANE_X`
          XZ – Rotate around local X, then Z.
        - `PLANE_Z`
          ZX – Rotate around local Z, then X.
        - `SWING_Y`
          Swing – Use the smallest single axis rotation, similar to Damped Track.

        Type:
        :   enum in [`'PLANE_X'`, `'PLANE_Z'`, `'SWING_Y'`], default `'PLANE_X'`

    rest_length
    :   Length at rest position

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

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_bulge_max
    :   Use upper limit for volume variation

        Type:
        :   boolean, default False

    use_bulge_min
    :   Use lower limit for volume variation

        Type:
        :   boolean, default False

    volume
    :   Maintain the object’s volume as it stretches

        Type:
        :   enum in [`'VOLUME_XZX'`, `'VOLUME_X'`, `'VOLUME_Z'`, `'NO_VOLUME'`], default `'VOLUME_XZX'`

    *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