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

assistant: ### Selecting a Brush

In the Tool Settings select the brush to use with the tool.
The Erase tool uses [Erase Brush](../brushes/index.xhtml#grease-pencil-draw-brushes-erase) types (soft, point and stroke).

### Dissolve Erasing

- Select an erase brush of type Soft/Hard.
- Adjust brush settings.
- Click and hold `LMB` or use the `Pen` tip to delete strokes on the viewport.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_erase_soft-01.png   Original drawing. | ../../../../_images/grease-pencil_modes_draw_tools_erase_soft-02.png   The eraser affect the transparency of the strokes. | ../../../../_images/grease-pencil_modes_draw_tools_erase_soft-03.png   Final result. |

### Point Erasing

- Select an erase brush of type Point.
- Adjust brush settings.
- Click and hold `LMB` or use the `Pen` tip to delete strokes on the viewport.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_erase_point-01.png   Original drawing. | ../../../../_images/grease-pencil_modes_draw_tools_erase_point-02.png   The eraser delete one point at a time. | ../../../../_images/grease-pencil_modes_draw_tools_erase_point-03.png   Final result. |

### Stroke Erasing

- Select an erase brush of type Stroke.
- Adjust brush settings.
- Click and hold `LMB` or use the `Pen` tip to delete strokes on the viewport.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_erase_stroke-01.png   Original drawing. | ../../../../_images/grease-pencil_modes_draw_tools_erase_stroke-02.png   The eraser delete one stroke at a time. | ../../../../_images/grease-pencil_modes_draw_tools_erase_stroke-03.png   Final result. |
user: Describe Face Group Boundaries Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Face Group Boundaries Node

[image reference removed]

The *Face Group Boundaries Node* finds the edges which lie on the boundaries of
specified regions. These edges could be used to mark seams for UV unwrapping,
for example.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Hair type particle system can be used for strand-like objects,
such as hair, fur, grass, quills, etc.

[image reference removed]

Particle hair systems example. Used for the grass and fur.
user: What is JSON and how is it used in Blender Python scripting?

assistant: To generate a valid JSON file use the [server generate](../../command_line/extension_arguments.xhtml#command-line-args-extension-server-generate)
Blender command-line tool:

```
blender --command extension server-generate --repo-dir=/path/to/packages
```

This creates an `index.json` listing from all the .zip extensions found in the –repo-dir location.

For more details, read the generated JSON
[API](https://developer.blender.org/docs/features/extensions/api_listing/).

### Testing

To test the generated repository, add a new Remote Repository from the Preferences:

- Get Extensions → Repositories → [+] → Add Remote Repository
- Paste the location of the generated JSON as the URL.
  So the example `/path/to/packages` would use the:

  - `file:///path/to/packages/index.json` on Linux and macOS.
  - `file:///C:/path/to/packages/index.json` on Windows.
  - `file://HOST/share/path/to/packages/index.json` for network shares on Windows.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.main_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.main_items "bpy.types.GeometryNodeForeachGeometryElementOutput.main_items") |  |
user: How do I use Getting Support in Blender? Include parameters, examples, warnings and best practices.

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

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

More details about support can be found on the [support page](https://www.blender.org/support/).
user: Give a detailed overview of Scenes as Assets: syntax, arguments, return values, common patterns.

assistant: Scenes can also be marked and used as [Assets](../../files/asset_libraries/index.html).
This allows them to appear in the [Asset Browser](../../editors/asset_browser.html) for reuse across projects.

Scene assets are a convenient way to manage pre-built scene templates, lighting rigs, or shot setups.
They store all relevant data (such as cameras, lights, and render settings) and can be dragged into any open Blender file.

When a scene asset is dragged into another window (except the Asset Browser itself),
Blender performs one of the following actions:

- **Link or Append:** Imports the scene into the current blend-file as a linked or appended data-block.
- **Activate:** Sets the imported (or linked) scene as the *active* one in the window.

Scene assets generate preview images automatically by rendering from the active camera in *Solid View* mode.
For this to work, the scene must contain an active camera.

Typical uses for scene assets include:

- Creating reusable lighting or studio setups.
- Storing shot layouts for multi-shot projects.
- Maintaining consistent render settings across files.
- Building base templates for new projects or departments.
user: Show practical ways to work with Scaling Rigid Bodies in a Blender add-on or script – include code.

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

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

assistant: Rim Effect samples (Mode: Add).

|  |  |  |  |
| --- | --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_rim_original.png   Original image. | ../../_images/grease-pencil_visual-effects_rim_no-blur.png   No blur. | ../../_images/grease-pencil_visual-effects_rim_blur.png   Blur. | ../../_images/grease-pencil_visual-effects_rim_mask.png   Mask color: Black. |
user: Explain Unwrapping in Multiple Steps in complete detail according to the official Blender documentation.

assistant: If you unwrap an entire mesh in one go, the resulting UV map may look rather messy.
In the example below, the ear and facial features are squashed and the neck is stretched
out way too far:

[image reference removed]

Bad unwrap, note ear and neck.

While you could of course start fixing this UV map by hand, it’s probably a better
idea to drop it and unwrap the mesh differently. We’ll divide it into pieces,
unwrapping each one separately with the most suitable projection.

We start by selecting just the head – excluding the eyes, ears, and neck –
and unwrapping it using [Sphere Projection](../../editing/uv.xhtml#bpy-ops-uv-sphere-project):

[image reference removed]

Unwrapping just the head.

Next, select the ear, align the 3D Viewport view to look straight at it,
and unwrap it using [Project from View](../../editing/uv.xhtml#bpy-ops-uv-project-from-view).

[image reference removed]

Unwrapping the ear.

The UV Editor only shows the ear at this point, but don’t worry: the UV coordinates
for the head are still there, just hidden. To make them visible again, either
select the head in the 3D Viewport again or enable
[Sync Selection](../../../../editors/uv/selecting.xhtml#bpy-types-toolsettings-use-uv-select-sync) in the UV Editor.

Next, you can unwrap the neck using [Cylinder Projection](../../editing/uv.xhtml#bpy-ops-uv-cylinder-project).

Once everything is unwrapped, you can select the whole mesh in the 3D Viewport to
see to the full UV map. Most likely, the different UV parts or “islands” will be
overlapping; you can fix this in the following ways:

- For each island, select a vertex and press `Ctrl`-`L` to select all the vertices
  it’s connected (Linked) to. You can also hover over the vertex and press `L`,
  or simply set the [Selection Mode](../../../../editors/uv/selecting.xhtml#bpy-ops-uv-select-mode) to *Island*.
  Once the island is selected, scale it down and move it to a place where it no
  longer overlaps the others.
- Alternatively, you can simply click [Pack Islands](../editing.xhtml#bpy-ops-uv-pack-islands) in the menu
  to have Blender lay out the islands automatically.

[image reference removed]

UV maps arranged together and stitched.

As a final step, you can align the islands to each other by moving and scaling,
then connect them using [Merge](../editing.xhtml#bpy-ops-uv-weld) – or better yet, [Stitch](../editing.xhtml#bpy-ops-uv-stitch).
user: Explain Reusing Existing Materials in complete detail according to the official Blender documentation.

assistant: Blender is built to allow you to reuse *anything*, including material settings,
between many objects. Instead of creating duplicate materials,
you can simply reuse an existing material.
There are several ways to do this using the Material’s data-block menu:

*Single Object* – With the object selected, click the sphere located to the left of the Material name.
A pop-up appears showing all the materials available in the current blend-file.
To use one, just click on it.

*Multiple Objects* – In the 3D Viewport, with `Ctrl`-`L`
you can quickly link all selected objects to the material (and other aspects)
of the [active object](../../scene_layout/object/selecting.xhtml#object-active).
Very useful if you need to set a large number of objects to the same material;
just select all of them,
then the object that has the desired material, and `Ctrl`-`L` links them to that “parent”.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Location
:   Location of the particle.

Radius
:   Size of the particle.

Random
:   A random per-point value in the range from 0 to 1.
    It can for example be used in combination with a color ramp, to randomize the point color.
user: Give a detailed overview of Default Settings: syntax, arguments, return values, common patterns.

assistant: - The **Edit** scene has a default duration of **10 seconds**, providing a starting point for new projects.
- The **Edit** scene is set as both the current scene and the active Sequencer scene.
- Resolution defaults to **1920 × 1080 HD** at **24 FPS**, suitable for most video work.
- The output format is preset for video rendering, allowing quick exports.
user: Give a detailed overview of BoidState(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # BoidState(bpy_struct)

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

*class* bpy.types.BoidState(*bpy_struct*)
:   Boid state for boid physics

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

    active_boid_rule_index
    :   Type:
        :   int in [0, inf], default 0

    falloff
    :   Type:
        :   float in [0, 10], default 0.0

    name
    :   Boid state name

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

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

    rules
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`BoidRule`](bpy.types.BoidRule.html#bpy.types.BoidRule "bpy.types.BoidRule"), (readonly)

    ruleset_type
    :   How the rules in the list are evaluated

        - `FUZZY`
          Fuzzy – Rules are gone through top to bottom (only the first rule which effect is above fuzziness threshold is evaluated).
        - `RANDOM`
          Random – A random rule is selected for each boid.
        - `AVERAGE`
          Average – All rules are averaged.

        Type:
        :   enum in [`'FUZZY'`, `'RANDOM'`, `'AVERAGE'`], default `'FUZZY'`

    volume
    :   Type:
        :   float in [0, 100], 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: What is Known Limitations and how is it used in Blender Python scripting?

assistant: ### Even Thickness

Solidify thickness is an approximation.
While *Even Thickness* and *High Quality Normals* should yield good results,
the final wall thickness is not guaranteed and may vary depending on the mesh topology.
Especially for vertices with more than three adjacent faces.

In order to maintain a precise wall thickness in every case, we would need to add/remove faces on
the offset shell, something this modifier does not do since this would add a lot of complexity.
The best option to preserve wall thickness is complex mode with constraints thickness mode,
but it is also not guaranteed to work perfect in every case.
user: What is Supported Modes & Object Types and how is it used in Blender Python scripting?

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.xhtml#editors-geometry-nodes-tool-context).
user: Describe Keying Flag Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Keying Flag Items

INSERTKEY_NEEDED:
:   Only Needed.

    Only insert keyframes where they’re needed in the relevant F-Curves.

INSERTKEY_VISUAL:
:   Visual Keying.

    Insert keyframes based on ‘visual transforms’.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`WindowManager.popmenu_begin__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popmenu_begin__internal "bpy.types.WindowManager.popmenu_begin__internal") | - [`WindowManager.popmenu_end__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popmenu_end__internal "bpy.types.WindowManager.popmenu_end__internal") |
user: Provide the full official documentation entry for Brush Settings, preserving all code examples.

assistant: ### General

### Unique

Deformation
:   Deformation type that is used by the brush.

    Drag:
    :   Pulls the displacement values in the direction of the brush.

    Pinch:
    :   Pulls the displacement values towards the center of the brush,
        creating hard surface effects without pinching the topology.

    Expand:
    :   Pushes the displacement values away from the brush center, smoothing the displacement.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Grid Intersect
:   The input grid used for intersection operations.
    Only the regions common to all intersecting grids will remain active.

Grid 1 Union Difference
:   The first input grid for boolean combination.
    Acts as the base grid to which the second grid is added or subtracted.

Grid 2 Union Difference
:   The second input grid used to modify *Grid 1* according to the selected operation.
user: Provide the full official documentation entry for Selecting View Layers, preserving all code examples.

assistant: At the top of the *View Layer Properties* tab is a list of all View Layers in the active scene.

[image reference removed]

View Layers list.

Name
:   The name of the active View Layer. Click to edit.

Add View Layer
:   Adds a new View Layer to the scene.

    - **New**: Adds an empty View Layer.
    - **Copy Settings**: Duplicates the current View Layer, including collection visibility and overrides.
    - **Blank**: Adds a new View Layer with all collections disabled.

Remove View Layer
:   Deletes the selected View Layer from the scene.
user: Show practical ways to work with Point Light in a Blender add-on or script – include code.

assistant: [[image reference removed]](../../_images/render_lights_light-object_viewport.png)

Point light.

The point light is an omnidirectional point of light,
that is, a point radiating the same amount of light in all directions.
It’s visualized by a plain, circled dot.
Being a point light source, the direction of the light hitting an object’s surface
is determined by the line joining the light and the point on the surface of the object itself.
It can be used as simple model of e.g. a light bulb.

Light intensity/energy decays based on (among other variables)
distance from the point light to the object. In other words,
surfaces that are further away will be rendered darker.

Power
:   Power of the light. Higher values increase the intensity of the light.
    Negative values can be set, but should be avoided for predictable and physically based result.

Radius
:   When larger than zero, light will be emitted from a spherical surfaces with the specified radius.
    Lights with larger size have softer shadows and specular highlights, and they will also appear dimmer
    because their power is distributed over a larger area.

Soft Falloff
:   Apply falloff to avoid sharp edges when the light geometry intersects with other objects.
user: What is ShaderNodeSqueeze(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeSqueeze(ShaderNode)

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

*class* bpy.types.ShaderNodeSqueeze(*ShaderNode*)
:   Deprecated

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_bisect_example.png>   Example of a common use of bisect. | <../../../../_images/modeling_meshes_editing_mesh_bisect_uv.jpg>   Example of bisect with the fill option enabled. |
user: How do I use Hints in Blender? Include parameters, examples, warnings and best practices.

assistant: - Ensure that the normals on the cage mesh point to the outside
  (they are used to determine the inside and outside of the cage).
- Besides the outer cage, more faces within the cage, either loose or forming another smaller cage,
  can be used for extra control. Such smaller cages may also overlap with the main cage.
  For example, to get extra control over eyes, two small sphere cages could be added around them.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Relative Path
:   Select the file path relative to the blend-file.

Accuracy
:   Sample accuracy, important for animation data (the lower the value, the more accurate).

Container
:   See [here](../../../files/media/video_formats.xhtml).

Channels
:   The number of audio source “locations” to encode.
    Each channel can be mixed to a separate file by enabling *Split Channels* (see below).

    Mono:
    :   Output a single audio channel.

    Stereo:
    :   Output two audio channels; typically a left and right channel.

    Stereo LFE:
    :   Output a two audio channels with a “low-frequency effects” channel for frequencies below 120.

    4 Channels:
    :   Output a four audio channels.

    5.1 Surround:
    :   Output a five audio channels with one LFE channel.

    6.1 Surround:
    :   Output a six audio channels with one LFE channel.

    7.1 Surround:
    :   Output a seven audio channels with one LFE channel.

Format
:   Some *Audio Containers* also have option to choose a codec.
    For more information see [here](../../../files/media/video_formats.xhtml).

Sample Rate
:   Sets the audio [sampling rate](https://en.wikipedia.org/wiki/Sampling_(signal_processing)#Sampling_rate).

Split Channels
:   Each audio channel will be rendered into a separate file.
user: How do I use Add-on Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Refresh Local
:   Scan extension & legacy add-ons for changes to modules & meta-data (similar to restarting).
    Any issues are reported as warnings.

Install from Disk
:   Install an extension from a `.zip` package.
    This is installed to a Local Repository and no updates will be available.

    This can also be used to install legacy Add-ons, for more information see:
    [Installing Legacy Add-ons](#prefs-extensions-install-legacy-addon).
user: How do I use Proxy Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Contains scene-wide proxy settings.

Storage
:   How proxies are stored for the project.

    Per Strip:
    :   Each strip can specify where to store its proxies (see below).

    Project:
    :   All proxies are stored in one directory.

        Proxy Directory
        :   The location to store the proxies for the project.

Set Selected Strip Proxies
:   Shows a pop-over that lets you choose the resolution(s) to generate
    and whether to overwrite existing proxy files. Once you confirm with the *Set* button,
    your choices are applied to the selected strips. You can view and tweak the
    settings for individual strips in the *Strip Proxy & Timecode* panel (see below).

    In the *Preview* mode, where the *Proxy* tab is not available,
    this is instead done through the menu View ‣ Proxy ‣ Setup.

Rebuild Proxy and Timecode Indices
:   Generates proxies and time indices for the selected strips.

    In the *Preview* mode, where the *Proxy* tab is not available,
    this is instead done through the menu View ‣ Proxy ‣ Rebuild.
user: Show practical ways to work with Screen(ID) in a Blender add-on or script – include code.

assistant: # Screen(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.Screen(*ID*)
:   Screen data-block, defining the layout of areas in a window

    areas
    :   Areas the screen is subdivided into

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

    is_animation_playing
    :   Animation playback is active

        Type:
        :   boolean, default False, (readonly)

    is_scrubbing
    :   True when the user is scrubbing through time

        Type:
        :   boolean, default False, (readonly)

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

    show_fullscreen
    :   An area is maximized, filling this screen

        Type:
        :   boolean, default False, (readonly)

    show_statusbar
    :   Show status bar

        Type:
        :   boolean, default False

    use_follow
    :   Follow current frame in editors

        Type:
        :   boolean, default False

    use_play_3d_editors
    :   Type:
        :   boolean, default False

    use_play_animation_editors
    :   Type:
        :   boolean, default False

    use_play_clip_editors
    :   Type:
        :   boolean, default False

    use_play_image_editors
    :   Type:
        :   boolean, default False

    use_play_node_editors
    :   Type:
        :   boolean, default False

    use_play_properties_editors
    :   Type:
        :   boolean, default False

    use_play_sequence_editors
    :   Type:
        :   boolean, default False

    use_play_spreadsheet_editors
    :   Type:
        :   boolean, default False

    use_play_top_left_3d_editor
    :   Type:
        :   boolean, default False

    statusbar_info()
    :   statusbar_info

        Returns:
        :   Status Bar Info

        Return type:
        :   string, (never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # GeometryNodeInputNamedLayerSelection(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.GeometryNodeInputNamedLayerSelection(*GeometryNode*)
:   Output a selection of a Grease Pencil layer

    *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: Explain DecimateModifier(Modifier) in complete detail according to the official Blender documentation.

assistant: # DecimateModifier(Modifier)

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

*class* bpy.types.DecimateModifier(*Modifier*)
:   Decimation modifier

    angle_limit
    :   Only dissolve angles below this (planar only)

        Type:
        :   float in [0, 3.14159], default 0.0872665

    decimate_type
    :   - `COLLAPSE`
          Collapse – Use edge collapsing.
        - `UNSUBDIV`
          Un-Subdivide – Use un-subdivide face reduction.
        - `DISSOLVE`
          Planar – Dissolve geometry to form planar polygons.

        Type:
        :   enum in [`'COLLAPSE'`, `'UNSUBDIV'`, `'DISSOLVE'`], default `'COLLAPSE'`

    delimit
    :   Limit merging geometry

        Type:
        :   enum set in [Mesh Delimit Mode Items](bpy_types_enum_items/mesh_delimit_mode_items.html#rna-enum-mesh-delimit-mode-items), default set()

    face_count
    :   The current number of faces in the decimated mesh

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

    invert_vertex_group
    :   Invert vertex group influence (collapse only)

        Type:
        :   boolean, default False

    iterations
    :   Number of times reduce the geometry (unsubdivide only)

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

    ratio
    :   Ratio of triangles to reduce to (collapse only)

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

    symmetry_axis
    :   Axis of symmetry

        Type:
        :   enum in [Axis Xyz Items](bpy_types_enum_items/axis_xyz_items.html#rna-enum-axis-xyz-items), default `'X'`

    use_collapse_triangulate
    :   Keep triangulated faces resulting from decimation (collapse only)

        Type:
        :   boolean, default False

    use_dissolve_boundaries
    :   Dissolve all vertices in between face boundaries (planar only)

        Type:
        :   boolean, default False

    use_symmetry
    :   Maintain symmetry on an axis

        Type:
        :   boolean, default False

    vertex_group
    :   Vertex group name (collapse only)

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

    vertex_group_factor
    :   Vertex group strength

        Type:
        :   float in [0, 1000], default 1.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: What is Overhang and how is it used in Blender Python scripting?

assistant: Extrusion 3D printers have a physical limit to the overhang that can be printed,
this display mode shows the overhang with angle range and axis selection.

Minimum/Maximum
:   Minimum/Maximum angle to display.

Axis
:   Axis and direction to use as the bases to calculate the angle to visualize.

[image reference removed]

Overhang.
user: Give a detailed overview of Voxelize Grid Node: syntax, arguments, return values, common patterns.

assistant: # Voxelize Grid Node

[image reference removed]

The *Voxelize Grid* node converts all active tiles in a sparse voxel grid
into fully populated voxel regions, removing sparseness.

In voxel-based grids such as signed distance fields (SDF) or fog volumes,
inactive areas are often stored as *tiles*—compact representations that save
memory by not allocating individual voxel values. This node expands those tiles
into explicit voxels, making every voxel within an active tile directly
accessible and editable.

This can be useful before performing operations that require dense voxel data,
such as sampling, filtering, or arithmetic operations that depend on
neighboring voxel values.
user: Give a detailed overview of Add Marker: syntax, arguments, return values, common patterns.

assistant: Places a new marker at the position of the mouse
(which is under the button in this case, not ideal but it is just how things work)
and then it can be moved to the needed location. When it is moved to the desired position,
`LMB` can be used to finish placing the new marker.
Also, `Return` and `Spacebar` can be used to finish placing the marker.
But it is faster to use `Ctrl`-`LMB` to place markers directly on the footage.
This shortcut will place the marker in the place you have clicked.

In addition to this until you have released the mouse button,
you can adjust the marker position by moving the mouse and
using the track preview widget to control how accurately the marker is placed.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: ### Format Items

A [list view](../../../../interface/controls/templates/list_view.xhtml#ui-list-view). to manage the dynamic list of inputs used in the format string.
Each entry corresponds to a value that can be inserted into the format using a placeholder.
See [Input Naming Behavior](#input-naming-behavior) to understand how inputs must be named.

Socket Type
:   The type of value for this input:

    Float:
    :   A floating-point number (e.g. `3.14`).

    Integer:
    :   An integer number (e.g. `42`).

    String:
    :   A text string.
user: Show practical ways to work with CompositorNodeCrop(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeCrop(CompositorNode)

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"), [`CompositorNode`](bpy.types.CompositorNode.html#bpy.types.CompositorNode "bpy.types.CompositorNode")

*class* bpy.types.CompositorNodeCrop(*CompositorNode*)
:   Crops image to a smaller region, either making the cropped area transparent or resizing the image

    *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")

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Asset Shelf in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Asset Shelf of the 3D View, showing material assets.

### Search

To search for assets, hover your mouse over the Asset Shelf, then press Ctrl-F and type a search query.
This will filter the poses to match what you typed.

### Tabs

[image reference removed]

The usage of catalogs as tabs.

Catalogs can be shown as individual tabs. Each tab will only show its content, and the content of its children.
That makes it easy to filter down to a certain set of assets.

### Display Options

[image reference removed]

Display options available for the asset shelf.

It is possible to change the size of items on the shelf by using the size property.

By toggling on the “Names” checkbox, the asset names will be shown in the shelf. Alternatively it is also
possible to hover over an item to show its name.

By default the shelf only has a height for one item row. To allow for more rows, drag it on the upper edge to increase
its size.

### Filter

By Active Tool
:   Only show brushes applicable for the currently active tool in the asset shelf.
user: Give a detailed overview of Weights: syntax, arguments, return values, common patterns.

assistant: The shape can be further tweaked by changing the weight of individual control
points in the [Transform Panel](properties/transform_panel.html) found in the Sidebar.

The property is called *W*; while there is also one called *Weight*,
this is the [Goal Weight](properties/transform_panel.html#surface-goal-weight) for soft body simulations.

[image reference removed]

A control point with a higher weight pulls the surface towards it.

Weights are necessary to achieve certain “pure” shapes like cylinders or spheres.
The [primitives](primitives.html) in the *Add* menu
have these preconfigured.

[image reference removed]

Control point weights on a spherical Surface.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`ThemeStyle.panel_title`](bpy.types.ThemeStyle.html#bpy.types.ThemeStyle.panel_title "bpy.types.ThemeStyle.panel_title") - [`ThemeStyle.tooltip`](bpy.types.ThemeStyle.html#bpy.types.ThemeStyle.tooltip "bpy.types.ThemeStyle.tooltip") | - [`ThemeStyle.widget`](bpy.types.ThemeStyle.html#bpy.types.ThemeStyle.widget "bpy.types.ThemeStyle.widget") |
user: Show practical ways to work with In Edit Mode in a Blender add-on or script – include code.

assistant: The pivot point becomes the center of the bounding box around the selected mesh elements.

[image reference removed]

The effects of rotation in different mesh selection modes.
The pivot point is shown by a yellow circle.

Median Point may again give a different result.

[image reference removed]

Difference between “Bounding Box Center” (left) and “Median Point” (right).
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`ClothSettings.effector_weights`](bpy.types.ClothSettings.html#bpy.types.ClothSettings.effector_weights "bpy.types.ClothSettings.effector_weights") - [`DynamicPaintSurface.effector_weights`](bpy.types.DynamicPaintSurface.html#bpy.types.DynamicPaintSurface.effector_weights "bpy.types.DynamicPaintSurface.effector_weights") - [`FluidDomainSettings.effector_weights`](bpy.types.FluidDomainSettings.html#bpy.types.FluidDomainSettings.effector_weights "bpy.types.FluidDomainSettings.effector_weights") | - [`ParticleSettings.effector_weights`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.effector_weights "bpy.types.ParticleSettings.effector_weights") - [`RigidBodyWorld.effector_weights`](bpy.types.RigidBodyWorld.html#bpy.types.RigidBodyWorld.effector_weights "bpy.types.RigidBodyWorld.effector_weights") - [`SoftBodySettings.effector_weights`](bpy.types.SoftBodySettings.html#bpy.types.SoftBodySettings.effector_weights "bpy.types.SoftBodySettings.effector_weights") |
user: Provide the full official documentation entry for Separate Cylindrical Node, preserving all code examples.

assistant: # Separate Cylindrical Node

[image reference removed]

The *Separate Cylindrical* node converts a vector from Cartesian coordinates (X, Y, Z)
into cylindrical coordinates (R, Φ, Z) and outputs each component separately. It is the inverse of the
[Combine Cylindrical](../../../../modeling/geometry_nodes/utilities/vector/combine_cylindrical.html) node.

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: Give a detailed overview of Decimate Geometry: syntax, arguments, return values, common patterns.

assistant: Reduces the face count of the selected geometry while minimizing shape changes.

Ratio
:   The target triangle count ratio. For example, enter 0.4 to keep collapsing edges
    until the triangle count is 40% of the original.

Vertex Group
:   Use the active vertex group when choosing which edges to collapse.
    The higher the vertex weights for an edge, the more likely it is to be chosen,
    even taking priority over “better” (shorter) candidates.

    Weight
    :   Factor by which to multiply the vertex weights.

    Invert
    :   Inverts the vertex weights, making edges with *lower* weights get collapsed first.

Symmetry
:   Maintain symmetry on either the *X*, *Y*, or *Z* axis.
user: Give a detailed overview of Multi-Object Editing: syntax, arguments, return values, common patterns.

assistant: Edit Mode and Pose Mode let you work with multiple objects even more
easily than described above, as they can have multiple objects in the mode
at the same time.

There are two ways of accomplishing this:

- If you’re not yet in the mode, you can simply select all the objects
  and enter it.
- If you’re already in the mode, you can bring other objects into it
  by clicking `Ctrl`-`LMB` on the dot in the
  [Outliner](../outliner/introduction.xhtml).
  Removing objects from the mode works in the same way.

Some points of note:

- The [Properties Editor](../properties_editor.xhtml) editor will only ever show the details
  (shape keys, UV maps…) of the active object, not of all the selected ones.
- Selecting any element from an object will make it the active one.
- There are limits to the edits you can make.
  For example, you can’t create an edge that connects vertices from
  different objects.
user: Describe Markup Style Guide from the Blender manual or Python API, including usage steps and snippets.

assistant: # Markup Style Guide

This page covers conventions for writing Blender’s documentation using reStructuredText (RST) markup syntax.
Following these conventions ensures clarity, consistency, and ease of maintenance.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Data Type
:   The [data type](../attributes_reference.html#attribute-data-types) used for the evaluated data.

Domain
:   Which [attribute domain](../attributes_reference.html#attribute-domains) to store the evaluated data on.
user: Show practical ways to work with Instances in a Blender add-on or script – include code.

assistant: # Instances

[image reference removed]

The three types of instances.

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

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

Instances can be created with geometry nodes using the [Instance on Points Node](instances/instance_on_points.xhtml).
user: How do I use Experimental in Blender? Include parameters, examples, warnings and best practices.

assistant: # Experimental

These preferences are reserved for features that are currently being worked on and are not yet complete.
Experimental features are only available in [Daily Builds](https://builder.blender.org/download/daily/).

[image reference removed]

Blender Preferences Experimental section.
user: How do I use Expression in Blender? Include parameters, examples, warnings and best practices.

assistant: This is a quick way to add drivers with a scripted expression.
First click the property you want to add a driver to, then type a hash `#` and a scripted expression.

Some examples:

- `#frame`
- `#frame / 20.0`
- `#sin(frame)`
- `#cos(frame)`
user: Give a detailed overview of NodeSocketFloatTimeAbsolute(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketFloatTimeAbsolute(NodeSocketStandard)

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

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

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Rotate UVs

The orientation of the UV texture is defined by each face.
If the image is, for example, upside down or laying on its side,
use the Face ‣ Rotate UVs (in the 3D Viewport in Face Select mode)
menu to rotate the UVs per face in 90-degree turns.

### Reverse UVs

The Face ‣ Reverse UVs tool mirrors the UVs per face,
which flips the image over, showing you the image reversed.