PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain ShaderNodeDisplacement(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeDisplacement(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.ShaderNodeDisplacement(*ShaderNode*)
:   Displace the surface along the surface normal

    space
    :   Space of the input height

        - `OBJECT`
          Object Space – Displacement is in object space, affected by object scale.
        - `WORLD`
          World Space – Displacement is in world space, not affected by object scale.

        Type:
        :   enum in [`'OBJECT'`, `'WORLD'`], default `'OBJECT'`

    *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 Action Menu in complete detail according to the official Blender documentation.

assistant: Merge Animation
:   This operator merges the animation of all selected objects into the animation of the
    active object. Since the data is moved and not copied, the source Actions might end up
    empty and without users.
    Note that this will not only merge the object level Action, but Actions on related data-blocks
    as well (See [Related data-blocks](../../../animation/actions.xhtml#working-with-actions)). As a result of that
    this operator can also be used to merge Actions of one Object. For example
    Translation & Rotation and animation on Shape Keys.

Separate Slots
:   This splits all Slots of the Action on the active Object into separate Actions.
    All users of those Slots will be re-assigned to their respective Action and
    the newly created Actions are named after the Slot.
    The source Action will not be deleted, but might end up with 0 users if no
    [Fake User](../../../files/data_blocks.xhtml#data-system-datablock-fake-user) is set.

Move Slots to new Action
:   This moves Slots selected in the [Channels Region](../../graph_editor/channels/introduction.xhtml#editors-graph-editor-channels-region)
    to a newly created Action. All users of those Slots are re-assigned to the new Action.
    If more than one Slot is selected, all Slots are moved into a single Action.

Push Down Action
:   Creates a new NLA track below the Action Track and moves the active action into it.
    This is the same as clicking [Push Down Action](../../nla/tracks.xhtml#bpy-ops-nla-action-pushdown)
    in the NLA editor.

Stash Action
:   Creates a new *muted* NLA track at the bottom of the NLA tracks and moves the active action into it.
    In effect, this sets the action aside for later use, disabling it so it no longer
    affects the animation. Later, you can choose to either unmute it again or delete it.

    If you click *New Action* in the data-block menu for an object that already has an
    active action, that previous action will be stashed automatically.
user: What is Properties Editor Sync and how is it used in Blender Python scripting?

assistant: When clicking the icon (not the name) of an item in the Outliner, the [Properties Editor](../properties_editor.xhtml)
editor will automatically switch to the relevant tab. This feature can be disabled using
the Properties editor’s [Sync with Outliner](../properties_editor.xhtml#bpy-types-spaceproperties-outliner-sync) option.
user: Show practical ways to work with Export Scene Operators in a Blender add-on or script – include code.

assistant:  Level, Log Level
        - **filter_glob** (*string**,* *(**optional**,* *never None**)*) – filter_glob

    File:
    :   [addons_core/io_scene_gltf2/__init__.py:1084](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/io_scene_gltf2/__init__.py#L1084)
user: How do I use Bone Roll in Blender? Include parameters, examples, warnings and best practices.

assistant: # Bone Roll

The bone roll is a part of a bone’s [rest pose](../../../../glossary/index.html#term-Rest-Pose) defining its default rotation around the bone’s length.
You can control the bone roll in *Edit Mode*.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Movie Clip
:   Used to select the movie clip whose distortion is to be used.
    This can be useful if more than one movie clips are present, each having a different distortion setting.
    For controls see [Data-Block Menu](../../../interface/controls/templates/data_block.html#ui-data-block).
user: Provide the full official documentation entry for Laplacian Smooth, preserving all code examples.

assistant: # Laplacian Smooth

See the [Laplacian Smooth Modifier](../../../modifiers/deform/laplacian_smooth.xhtml) for details.

Laplacian smooth uses an alternative smoothing algorithm that better preserves larger details and
this way the overall shape of the mesh. Laplacian smooth exists as a mesh operation and
as a non-destructive modifier.
user: Give a detailed overview of Rim Visual Effect: syntax, arguments, return values, common patterns.

assistant: # Rim Visual Effect

The *Rim* Visual Effect shows a simulated rim light on the object contour.

For simulating the rim light, a masked color silhouette of the object is
displaced in horizontal and/or vertical direction.

Many blending modes can be applied to the resulting mask.
user: What is Compositor and how is it used in Blender Python scripting?

assistant: The Compositor works smoothly with multi-view images.
The compositing of a view is completed before the remaining views start to be composited.
The pipeline is the same as the single-view workflow, with the difference that you can use images,
movies or image sequences in any of the supported multi-view formats.

[image reference removed]

Compositor, backdrop and Split Viewer node.

The views to render are defined in the current scene views,
in a similar way as you define the composite output resolution in the current scene render panel,
regardless of the Image nodes resolutions or Render Layers from different scenes.

Switch View Node
:   If you need to treat the views separately, you can use
    the [Switch View node](../../../../compositing/types/utilities/switch_stereo_view.xhtml)
    to combine the views before an Output node.
user: What is Degenerate Dissolve and how is it used in Blender Python scripting?

assistant: Collapses any selected edges that are shorter than a certain length.
This also results in the removal of small faces.

If two vertices are near to each other but are not connected by an edge,
they will not be merged; you can use [Merge by Distance](#bpy-ops-mesh-remove-doubles)
for that.

Merge Distance
:   Edges shorter than this length will be collapsed.
user: Explain Annotation(ID) in complete detail according to the official Blender documentation.

assistant: # Annotation(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.Annotation(*ID*)
:   Freehand annotation sketchbook

    animation_data
    :   Animation data for this data-block

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

    layers
    :   Type:
        :   [`AnnotationLayers`](bpy.types.AnnotationLayers.html#bpy.types.AnnotationLayers "bpy.types.AnnotationLayers") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`AnnotationLayer`](bpy.types.AnnotationLayer.html#bpy.types.AnnotationLayer "bpy.types.AnnotationLayer"), (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: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Add/Remove
:   Adds/Removes an object or material from matte, by picking a color from the *Pick* output.

Matte ID
:   List of object and material crypto IDs to include in matte.
    This can be used for example to quickly clear all mattes by deleting the text
    or used to copy-and-paste crypto IDs from other software.
user: How do I use Lightmap Pack in Blender? Include parameters, examples, warnings and best practices.

assistant: Places each selected face separately on the UV map. Lightmaps are commonly used for baking lighting information
into a texture for use in realtime rendering – as such, they prioritize using as much of the texture as possible,
typically resulting in a disconnected and distorted UV map that would be unsuitable for manual texturing work.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Selection
:   Selected Faces
    :   Only unwraps the selected faces.

    All Faces
    :   Unwraps the whole mesh.

Share Texture Space
:   You can use [Multi-Object Editing](../../../editors/3dview/modes.xhtml#dview-multi-object-mode) to generate UV maps for multiple meshes at the same time.
    When *Share Texture Space* is enabled, the UV maps won’t overlap each other,
    so that you can later use the same lightmap texture for all the meshes.

New UV Map
:   Creates a new UV map instead of overwriting the currently selected one. See [UV Maps](../uv/uv_texture_spaces.xhtml#uv-maps-panel).

Pack Quality
:   Higher values result in a UV map that wastes less space (but also takes longer to calculate).

Margin
:   How much empty space to leave between the faces in the UV map.
user: How do I use Smart UV Project in Blender? Include parameters, examples, warnings and best practices.

assistant: Examines the angles between the selected faces, cuts them along any sharp edges, then projects each separated group
of faces along its average normal and lays it out on the UV map. You can also set up
[seams](../uv/unwrapping/seams.xhtml) for additional cutting. This is a good method for, say,
mechanical objects or architecture.

[image reference removed]

Smart UV project on a truncated pyramid.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Angle Limit
:   The maximum allowed angle between the normals of adjacent faces before they’re split off from each other.
    A low limit will create lots of small UV islands with little distortion, while a high limit will create
    a few large islands with potentially more distortion.

Margin Method
:   The meaning of the *Island Margin* parameter, which determines the size of the empty space between UV islands.

    Scaled
    :   The *Island Margin* is a more or less arbitrary measure with no direct relation to the sizes of the
        UV islands or the texture.

    Add
    :   As above, but without the internally calculated scaling factor.

    Fraction
    :   The *Island Margin* is a fraction of the UV unit square. This means that, if you have a 1024x1024
        texture and set the *Island Margin* to 1/1024, each UV island will have a margin of 1 pixel around it
        (and islands will be no closer than 2 pixels to each other).

Rotation Method
:   Axis-aligned
    :   Automatically rotate to avoid wasting space.

    Axis-aligned (Horizontal)
    :   Rotate islands to be aligned horizontally.

    Axis-aligned (Vertical)
    :   Rotate islands to be aligned vertically.

Island Margin
:   How much empty space to leave between islands. Controlled by *Margin Method*.

Area Weight
:   With a value of 0, the projection vector of each face group is simply the average of its face normals.
    With a value of 1, it’s an average that’s weighted using the faces’ areas. Other values blend between the two.

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.xhtml), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.xhtml).

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: How do I use Bpy.Types.Event in Blender? Include parameters, examples, warnings and best practices.

assistant: Event.ascii Event.ctrl Event.direction Event.hyper Event.is_consecutive Event.is_mouse_absolute Event.is_repeat Event.is_tablet Event.mouse_prev_press_x Event.mouse_prev_press_y Event.mouse_prev_x Event.mouse_prev_y Event.mouse_region_x Event.mouse_region_y Event.mouse_x Event.mouse_y Event.ndof_motion Event.oskey Event.pressure Event.shift Event.tilt Event.type Event.type_prev Event.unicode Event.value Event.value_prev Event.xr Event.bl_rna_get_subclass() Event.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Much like in real-life skeletons, Bones are the building blocks of Armatures.
Each bone has a resting position, orientation, and length – and all of these
can be changed while posing or animating.

You can change the way bones are displayed in the armature’s
[Viewport Display](../properties/display.xhtml) settings.
user: What is Update Scene Frame Range and how is it used in Blender Python scripting?

assistant: For Scene strips only – Updates the strip’s [Time](../../../editors/video_sequencer/sequencer/sidebar/strip.html#sequencer-strips-properties-time)
properties to match the referenced scene’s frame range.
This operator should be used when the referenced scene’s length is extended or shortened.
user: How do I use MovieTrackingPlaneMarker(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MovieTrackingPlaneMarker(bpy_struct)

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

*class* bpy.types.MovieTrackingPlaneMarker(*bpy_struct*)
:   Match-moving plane marker data for tracking

    corners
    :   Array of coordinates which represents UI rectangle corners in frame normalized coordinates

        Type:
        :   float multi-dimensional array of 4 \* 2 items in [-inf, inf], default ((0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0))

    frame
    :   Frame number marker is keyframed on

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

    mute
    :   Is marker muted for current frame

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

assistant: # Spline IK

Spline IK is a constraint which aligns a chain of bones along a curve. By leveraging the ease
and flexibility of achieving aesthetically pleasing shapes offered by curves and
the predictability and well-integrated control offered by bones,
Spline IK is an invaluable tool in the riggers’ toolbox.
It is particularly well suited for rigging flexible body parts such as tails, tentacles,
and spines, as well as inorganic items such as ropes.

Full description of the settings for the spline IK can be found on
the [Spline IK](../../../../constraints/tracking/spline_ik.xhtml) page.
user: Explain Advanced Operations in complete detail according to the official Blender documentation.

assistant: If the web-based interface does not suit your needs, PO-files can be downloaded, edited locally, and uploaded back to
the platform.

### Installing

Before proceeding with translation tasks, ensure the manual builds correctly by following the
[Getting Started](../manual/index.xhtml#about-getting-started) section.

#### Language Files

Run the following command from the manual’s root directory:

```
make checkout_locale
```

You will be prompted to specify the language folder to download. For example, type `fr` for French and press
`Return`. The command creates a `locale/fr` subdirectory after downloading.

Example directory structure:

You should have a directory layout like this:

```
blender-manual
   |- locale/
   |  |- fr/
   |  |  |- LC_MESSAGES/
   |- manual/
```

Alternatively, download the PO files directly from Weblate by navigating to the `Files` menu on the language’s page.

#### PO-File Editor

To edit the PO files, install a PO-file editor to modify the translation files. [Poedit](https://poedit.net/) is
recommended, but other editors are also suitable.

### Building with Translations

To build the manual with translations applied run the following commands in a terminal:

- **Linux/macOS**:

  ```
  make -e BF_LANG=fr
  ```
- **Windows**:

  ```
  set BF_LANG=fr
  make html
  ```

### Editing Translation Files

The PO files in the `LC_MESSAGES` folder include:

- `blender_manual.po`: The main file containing user manual translations.
- `sphinx.po`: A smaller file for translating the website theme.

1. Use the PO editor to open these files. Each entry represents a section of the manual.
2. Translate any untranslated strings using the input field provided by the editor.
3. Save changes and upload the modified `.po` files back to Weblate.

### Maintenance

#### Keeping Track of Fuzzy Strings

When the manual is updated, outdated translations are marked as fuzzy. To track these run:

```
make report_po_progress
```

For a detailed report, run:

```
python tools/translations/report_translation_progress.py locale/fr/
```

This lists files with fuzzy or empty strings. For more options, see:

```
python tools/translations/report_translation_progress.py --help
```

#### Updating PO Files

Administrators regularly update PO files to match the latest English manual (typically weekly). The last update can be
checked on the
[Blender Manual Translations](https://projects.blender.org/blender/blender-manual-translations) project page.

Translators can update files locally using:

```
make update_po
```

However, uploading these files to Weblate is not permitted.
user: Explain Toolbar in complete detail according to the official Blender documentation.

assistant: # Toolbar

The following tools are available in Edit Mode:

[Select](../../../interface/selecting.xhtml)
:   Select control points.

Cursor
:   Change the location of the [3D Cursor](../../../editors/3dview/3d_cursor.xhtml).

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.xhtml)
    :   Editable bounding box for scaling control points.

Transform
:   Combined tool for translating, rotating, and scaling.

[Annotate](../../../interface/annotate_tool.xhtml)
:   Draw free-hand annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml)
:   Measure distances in the scene.

[Shear](../../meshes/editing/mesh/transform/shear.xhtml)
:   Shear control points along a certain axis.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Noise Basis
:   Shape of wave to produce bands.

    Sine, Saw, Triangle

Wood Type
:   Set the bands to either straight or ring-shaped, with or without turbulence.

    Bands, Rings, Band Noise, Ring Noise

Noise Type
:   There are two methods available for the Noise function.

    Soft, Hard

Size
:   Dimension of the Noise table.

Turbulence
:   Turbulence of the Band Noise and Ring Noise types.
user: How do I use Splash Screen in Blender? Include parameters, examples, warnings and best practices.

assistant: When Blender is configured for a particular studio or a project, it can be
helpful to customize the splash screen so artists know which version they
are running.

The `BLENDER_CUSTOM_SPLASH` [environment variable](command_line/arguments.xhtml#command-line-args-environment-variables)
replaces the entire splash image, while `BLENDER_CUSTOM_SPLASH_BANNER`
only overlays a banner.
user: Describe Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: # Settings

General settings for Grease Pencil strokes.

[image reference removed]

Settings panel.

Stroke Depth Order
:   Defines how the strokes are ordered in 3D space (for objects not displayed *In Front*).

    2D Layers:
    :   The Strokes drawing order respect the order of the 2D layers list (top to bottom)
        and ignores the real position of the strokes in 3D space.
        See [2D Layers](layers.html) for more information.

    3D Location:
    :   The strokes drawing order is based on the stroke location in 3D space.

    |  |  |
    | --- | --- |
    | <../../_images/grease-pencil_properties_strokes_depth-order-2d.png>   Blue, Green and Red strokes in three different layers using 2D Layers depth order. | <../../_images/grease-pencil_properties_strokes_depth-order-3d.png>   Blue, Green and Red strokes in three different layers using 3D Location depth order. |
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FModifier.name`](bpy.types.FModifier.html#bpy.types.FModifier.name "bpy.types.FModifier.name") - [`FModifier.type`](bpy.types.FModifier.html#bpy.types.FModifier.type "bpy.types.FModifier.type") - [`FModifier.show_expanded`](bpy.types.FModifier.html#bpy.types.FModifier.show_expanded "bpy.types.FModifier.show_expanded") - [`FModifier.mute`](bpy.types.FModifier.html#bpy.types.FModifier.mute "bpy.types.FModifier.mute") - [`FModifier.is_valid`](bpy.types.FModifier.html#bpy.types.FModifier.is_valid "bpy.types.FModifier.is_valid") - [`FModifier.active`](bpy.types.FModifier.html#bpy.types.FModifier.active "bpy.types.FModifier.active") | - [`FModifier.use_restricted_range`](bpy.types.FModifier.html#bpy.types.FModifier.use_restricted_range "bpy.types.FModifier.use_restricted_range") - [`FModifier.frame_start`](bpy.types.FModifier.html#bpy.types.FModifier.frame_start "bpy.types.FModifier.frame_start") - [`FModifier.frame_end`](bpy.types.FModifier.html#bpy.types.FModifier.frame_end "bpy.types.FModifier.frame_end") - [`FModifier.blend_in`](bpy.types.FModifier.html#bpy.types.FModifier.blend_in "bpy.types.FModifier.blend_in") - [`FModifier.blend_out`](bpy.types.FModifier.html#bpy.types.FModifier.blend_out "bpy.types.FModifier.blend_out") - [`FModifier.use_influence`](bpy.types.FModifier.html#bpy.types.FModifier.use_influence "bpy.types.FModifier.use_influence") - [`FModifier.influence`](bpy.types.FModifier.html#bpy.types.FModifier.influence "bpy.types.FModifier.influence") |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

The Subdivide modifier.

Subdivision Type
:   Catmull-Clark:
    :   Subdivides and smooths the surfaces.

    Simple:
    :   Only subdivides the surfaces, without any smoothing.

Subdivisions
:   Recursively adds more points.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Select Edge Loops, preserving all code examples.

assistant: Holding `Alt` while selecting an edge selects a loop of edges that are connected in
a line end-to-end, passing through the edge under the mouse pointer.
Holding `Shift`-`Alt` while clicking adds to the current selection.

[image reference removed]

Longitudinal and latitudinal edge loops.

The left sphere shows an edge that was selected longitudinally. Notice how the loop is open.
This is because the algorithm hit the vertices at the poles and is terminated
because the vertices at the pole connect to more than four edges. However,
the right sphere shows an edge that was selected latitudinally and has formed a closed loop.
This is because the algorithm hit the first edge that it started with.

### Select Edge Loops (All Boundaries)

All boundary edges can be selected by performing a second loop select action on a boundary edge.

This can be useful for selecting boundaries for meshes that include triangles and n-gons,
where loop select would not otherwise select the full boundary.

[image reference removed]

The second loop select action is shown on the right.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Directory
:   The base output directory.

File Name
:   The base name of the file.
    The final filename may also include frame numbers or layer names depending on the settings.

Media Type
:   Determines how multiple inputs are stored:

    Image:
    :   Saves each input as a separate image file.
        Each input can use its own image format settings.

    Multi-Layer EXR:
    :   Saves all inputs together in a single multi-layer OpenEXR file.

### Node Format

This panel controls file format and encoding options, depending on the *Media Type*:

- **Image**: Controls the default format and encoding for all outputs.
  To override settings for an individual output, enable *Override Node Format* in the *Images/Layers* panel.
  See [Saving Images](../../../files/media/image_formats.xhtml#bpy-types-imageformatsettings) for details on supported formats and options.
- **Multi-Layer EXR**: See [OpenEXR](../../../files/media/image_formats.xhtml#files-images-openexr) for EXR-specific settings.

### Images/Layers

Lists all input sockets of the node.
The name of each input socket is used to construct the final file name.

When saving individual images, each output can be renamed and will be written to disk
using either the global *Node Format* settings or its own overridden settings.
When using *Multi-Layer EXR*, each input is stored as a separate layer within the file.

Override Node Format
:   Allows the selected output to use a custom format instead of the global *Node Format*.

#### Item Format

When *Override Node Format* is enabled, this panel controls the format and encoding options
for the selected output image.
See [Saving Images](../../../files/media/image_formats.xhtml#bpy-types-imageformatsettings) for details.

### Output Paths

Displays the final file path and extension for each input/layer, based on current settings.
This helps verify that outputs are named and organized correctly.
user: How do I use Enabling Add-on in Blender? Include parameters, examples, warnings and best practices.

assistant: This add-on is enabled by default, in case it is not:

1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “FBX” and check the *Enable Add-on* checkbox.
user: What is Naming and Nesting and how is it used in Blender Python scripting?

assistant: Collections can be named and sorted hierarchically.
Just like folders can have subfolders in any operating system,
collections can have nested collections too.

[image reference removed]

Nested collections.

For example: a *house* collection can contain a *bedroom* collection,
which in turn contains a *furniture* collection referencing a bed, a cabinet and other objects.
user: Give a detailed overview of Rendering: syntax, arguments, return values, common patterns.

assistant: The render and output settings of the Sequencer Scene are the same as for regular scenes.
They can be found in the Output tab in the Properties editor. Note that these settings
follow the active scene in the window by default (unless there is a Scene pinned to the
properties editor).

When the active scene is different from the Sequencer Scene in the current workspace,
the “Render” menu will include separate options to render the Sequencer Scene (and not the active Scene).
user: What is TextureNodeTexture(TextureNode) and how is it used in Blender Python scripting?

assistant: # TextureNodeTexture(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.TextureNodeTexture(*TextureNode*)
:   node_output
    :   For node-based textures, which output node to use

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is reflected for each wavelength.

Roughness
:   Controls the amount of color that is reflected back to the camera,
    higher values reflect more color and can give a dusty appearance, while lower values look fuzzy and darker.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Value
:   The value of the input *Value* at the sample point.

Position
:   The position at the sample along the spline.

Tangent
:   The normalized [curve tangent](../read/curve_tangent.xhtml) at the sample.

Normal
:   The normalized [curve normal](../../geometry/read/normal.xhtml) at the sample.
user: Describe ShaderNodeParticleInfo(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeParticleInfo(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.ShaderNodeParticleInfo(*ShaderNode*)
:   Retrieve the data of the particle that spawned the object instance, for example to give variation to multiple instances of an object

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Transfer Weights in a Blender add-on or script – include code.

assistant: Copy weights from other objects to the vertex groups of the active object.

By default this tool copies only the active (selected) vertex group of the source object
to the active vertex group of target object or creates a new one if the group does not exist.
However, you can change the tool’s behavior in the [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.

For example, to transfer all existing vertex groups from the source objects to the target,
change the *Source Layers Selection* option to *By Name*.

### Prepare the Copy

You first select all source objects, and finally the target object
(the target object must be the active object).

It is important that the source objects and the target object are at the same location.
If they are placed side-by-side, then the weight transfer will not work. (See the *Vertex Mapping* option.)
You can place the objects on different layers,
but you have to ensure that all objects are visible when you call the tool.

Now ensure that the target object is in Weight Paint Mode.
Open the Toolbar and call the *Transfer Weights* tool in the *Weight Tools* panel.

### Adjust Last Operation Panel Confusion

You may notice that the [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel stays available
after the weight transfer is done. The panel only disappears
when you call another Operator that has its own [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.
This can lead to confusion when you use Transfer weights repeatedly after you changed your vertex groups.
If you then use the still-visible [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel,
then Blender will reset your work to its state right before you initially called the *Transfer Weights* tool.

So when you want to call the *Transfer Weights* tool again after you made some changes to your
vertex groups, then **always** use the *Transfer Weights* button,
even if the [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel is still available.
Unless you really want to reset your changes to the initial call of the tool.
user: Explain Installing Python in complete detail according to the official Blender documentation.

assistant: 1. Download the [Python installation package](https://www.python.org/downloads/) for Windows. In this guide version
   3.9.x is used.
2. Install Python with the installation wizard. Please make sure that you enable the “Add Python to PATH” option:

   [image reference removed]

   The option must be enabled so you can build the manual with the make script.

   All other settings can remain as set by default.
user: Explain GeometryNodeSampleGridIndex(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSampleGridIndex(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.GeometryNodeSampleGridIndex(*GeometryNode*)
:   Retrieve volume grid values at specific voxels

    data_type
    :   Node socket data type

        Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Edges in a Blender add-on or script – include code.

assistant: # Edges

Allow the edges in a mesh object to act like springs.
See [interior forces](../forces/interior.xhtml).

Springs
:   Use a specified vertex group for spring strength values.

Pull
:   The spring stiffness for edges (how much the edges are allowed to stretch).
    A low value means very weak springs (a very elastic material),
    a high value is a strong spring (a stiffer material) that resists being pulled apart.

    A value of 0.5 is latex, 0.9 is like a sweater, 0.999 is a highly-starched napkin or leather.
    The soft body simulation tends to get unstable if you use a value of 0.999,
    so you should lower this value a bit if that happens.

Push
:   How much the soft body resists being scrunched together, like a compression spring.
    Low values for fabric, high values for inflated objects and stiff material.

Damp
:   The friction for edge springs. High values (max of 50) dampen the *Push*/*Pull* effect and calm down the cloth.

Plasticity
:   Permanent deformation of the object after a collision.
    The vertices take a new position without applying the modifier.

Bending
:   This option creates virtual connections between a vertex and the vertices connected to its neighbors.
    This includes diagonal edges. Damping also applies to these connections.

Length
:   The edges can shrink or be blown up. This value is given in percent,
    0 disables this function. 100% means no change, the body keeps 100% of its size.

Collision
:   Edge
    :   Checks for edges of the soft body mesh colliding.

    Face
    :   Checks for any portion of the face of the soft body mesh colliding (which is computationally intensive).
        While *Face* enabled can solve collision errors, there does not seem to be any dampening settings for it.
        So parts of the soft body object near a collision mesh tend to “jitter” as they bounce off and fall back,
        even when there is no motion of any meshes. Edge collision has dampening, so that can be controlled,
        but Deflection dampening value on a collision object does not seem to affect the face collision.
user: Show practical ways to work with General in a Blender add-on or script – include code.

assistant: # General

*Sculpt Mode* is similar to *Edit Mode* in that it is used to alter the shape of a model,
but Sculpt Mode uses a very different workflow:
instead of dealing with individual elements (vertices, edges, and faces),
an area of the model is primarily changed using brushes.

[image reference removed]

Sculpting Mode Example.

Sculpt Mode is accessed from the mode menu of the [3D Viewport header](../../../editors/3dview/modes.html)
or with the pie menu via `Ctrl`-`Tab`.
Once inside Sculpt Mode, the Toolbar and Tool Settings of the 3D Viewport will change to
Sculpt Mode specific panels. The cursor will change to a circle, to indicate the size of the brush.

The following pages will briefly explain the fundamental features and concepts of *Sculpt Mode*,
including various links to other pages for more details.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`ColorRamp.elements`](bpy.types.ColorRamp.html#bpy.types.ColorRamp.elements "bpy.types.ColorRamp.elements") - [`ColorRampElements.new`](bpy.types.ColorRampElements.html#bpy.types.ColorRampElements.new "bpy.types.ColorRampElements.new") | - [`ColorRampElements.remove`](bpy.types.ColorRampElements.html#bpy.types.ColorRampElements.remove "bpy.types.ColorRampElements.remove") |
user: Describe Combine Cylindrical Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Combine Cylindrical Node

[image reference removed]

The *Combine Cylindrical* node converts cylindrical coordinates (R, Φ, Z)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Cylindrical](../../../../modeling/geometry_nodes/utilities/vector/separate_cylindrical.xhtml) node.

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: Give a detailed overview of Header: syntax, arguments, return values, common patterns.

assistant: Show Only Selected
:   This option is only available if the object is in Edit Mode.
    When checked, only data for the selected geometry elements is shown.

Use Filter
:   Whether to use the filters that are defined in the Sidebar (see below).

### View Menu

Toolbar `T`
:   Show or hide the tab panel on the left for creating and manipulating markers and masks.

Sidebar `N`
:   Show or hide the [Sidebar](../interface/window_system/regions.xhtml#ui-region-sidebar).

---

Internal Attributes
:   Display attributes with names starting with a period that are meant for internal use.

---

Area
:   Area controls. See the [user interface](../interface/window_system/areas.xhtml)
    documentation for more information.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Blur Visual Effect.

Samples
:   Number of blur samples (0 disabled the blur effect).

Use Depth of Field
:   When enabled, the blur effect uses the focal plane distance of the actual camera to
    calculate the object blur. Only available in camera view.

Size X, Y
:   Control the blur scale in pixels on the X and Y axis.

Rotation
:   Control the Rotation of the blur.
user: How do I use Density in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Decimate

Simplifies an F-Curve by removing the keyframes that influence its shape the least.

Mode
:   How to pick the number of keyframes to delete.

    Ratio
    :   Deletes a certain percentage of keyframes.

        Remove
        :   The percentage of keyframes to remove.

    Error Margin
    :   Deletes as many keyframes as possible while ensuring the F-Curve’s shape changes
        no more than a certain amount.

        Max Error Margin
        :   How much the decimated curve may deviate from the original.

### Bake Keyframes

Creates a keyframe at every frame.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_sample.png   F-Curve before baking. | ../../../_images/editors_graph-editor_fcurves_editing_sample2.png   F-Curve after baking. |

### Clean Keyframes

Finds redundant keyframes among the selected ones and deletes them. A keyframe is seen as
redundant if it has the same value as its neighbors – even if the curve segments around it
aren’t flat.

Threshold
:   Value threshold. By increasing this, you can also delete keyframes that *almost* have the
    same value as their neighbors.

Channels
:   Cleans all the keyframes (even unselected ones) in the selected F-Curves.
    If a curve is left with only one keyframe, it’s deleted entirely.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_clean1.png   F-Curve before cleaning. | ../../../_images/editors_graph-editor_fcurves_editing_clean2.png   F-Curve after cleaning. |