PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Sound(ID) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Sound(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.Sound(*ID*)
:   Sound data-block referencing an external or packed sound file

    channels
    :   Definition of audio channels

        - `INVALID`
          Invalid – Invalid.
        - `MONO`
          Mono – Mono.
        - `STEREO`
          Stereo – Stereo.
        - `STEREO_LFE`
          Stereo LFE – Stereo FX.
        - `CHANNELS_4`
          4 Channels – 4 Channels.
        - `CHANNELS_5`
          5 Channels – 5 Channels.
        - `SURROUND_51`
          5.1 Surround – 5.1 Surround.
        - `SURROUND_61`
          6.1 Surround – 6.1 Surround.
        - `SURROUND_71`
          7.1 Surround – 7.1 Surround.

        Type:
        :   enum in [`'INVALID'`, `'MONO'`, `'STEREO'`, `'STEREO_LFE'`, `'CHANNELS_4'`, `'CHANNELS_5'`, `'SURROUND_51'`, `'SURROUND_61'`, `'SURROUND_71'`], default `'INVALID'`, (readonly)

    filepath
    :   Sound sample file used by this Sound data-block

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

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

    samplerate
    :   Sample rate of the audio in Hz

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

    use_memory_cache
    :   The sound file is decoded and loaded into RAM

        Type:
        :   boolean, default False

    use_mono
    :   If the file contains multiple audio channels they are rendered to a single one

        Type:
        :   boolean, default False

    factory
    :   The aud.Factory object of the sound.

        (readonly)

    pack()
    :   Pack the sound into the current blend file

    unpack(*\**, *method='USE_LOCAL'*)
    :   Unpack the sound to the samples filename

        Parameters:
        :   **method** (enum in [Unpack Method Items](bpy_types_enum_items/unpack_method_items.html#rna-enum-unpack-method-items), (optional)) – method, How to unpack

    *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 Inputs and how is it used in Blender Python scripting?

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

Roughness
:   Influences sharpness of the refraction; perfectly sharp at 0.0 and smoother with higher values.

IOR
:   Index of refraction ([IOR](../../../glossary/index.xhtml#term-IOR)) defining how much the ray changes direction. At 1.
    0 rays pass straight through like transparent; higher values give more refraction.

Normal
:   Normal used for shading.

### Thin Film Cycles Only

Thin Film simulates the effect of interference in a thin film sitting on top of the material.
This causes the specular reflection to be colored in a way which strongly depends on the view
angle as well as the film thickness and the index of refraction ([IOR](../../../glossary/index.xhtml#term-IOR)) of the film and
the material itself.

This effect is commonly seen on e.g. oil films, soap bubbles or glass coatings. While its
influence is more obvious in specular highlights, it also affects transmission.

Thickness
:   The thickness of the film in nanometers. A value of 0 disables the simulation.
    The interference effect is strongest between roughly 100 and 1000 nanometers, since this is
    near the wavelengths of visible light.

IOR
:   Index of refraction ([IOR](../../../glossary/index.xhtml#term-IOR)) of the thin film.
    The common range for this value is between 1.0 (vacuum and air) and roughly 2.0,
    though some materials can reach higher values.
    The default value of 1.33 is a good approximation for water.
    Note that when the value is set to 1.0 or to the main IOR of the material, the thin film
    effect disappears since the film optically blends into the air or the material.
user: Explain Index Node in complete detail according to the official Blender documentation.

assistant: # Index Node

[image reference removed]

The *Index* node gives an integer value indicating the position of each element in the list,
starting at zero. This depends on the internal order of the data in the geometry, which is not
necessarily visible in the 3D Viewport. However, the index value is visible in the left-most column
in the [Spreadsheet Editor](../../../../editors/spreadsheet.html).
user: How do I use Sort Elements in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sort Elements

This tool (available from the context menu, *Vertices*, *Edges* and *Faces* menus)
allows you to reorder the matching selected mesh elements, following various methods.
Note that when called from the context menu,
the affected element types are the same as the active select modes.

View Z Axis
:   Sort along the active view’s Z axis, from farthest to nearest by default
    (use *Reverse* if you want it the other way).

View X Axis
:   Sort along the active view’s X axis, from left to right by default (again, there is the *Reverse* option).

Cursor Distance
:   Sort from nearest to farthest away from the 3D cursor position (*Reverse* also available).

Material
:   Sort faces, and faces only, from those having the lowest material’s index to those having the highest.
    Order of faces inside each of those “material groups” remains unchanged.
    Note that the *Reverse* option only reverses the order of the materials,
    *not* the order of the faces inside them.

Selected
:   Move all selected elements to the beginning (or end, if *Reverse* enabled),
    without affecting their relative orders.
    Warning: This option will also affect **unselected** elements’ indices!

Randomize
:   Randomizes indices of selected elements (*without* affecting those of unselected ones).
    The seed option allows you to get another randomization –
    the same seed over the same mesh or set of selected elements will always give the same result!

Reverse
:   Simply reverse the order of the selected elements.
user: Describe GeometryNodeCurveEndpointSelection(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeCurveEndpointSelection(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.GeometryNodeCurveEndpointSelection(*GeometryNode*)
:   Provide a selection for an arbitrary number of endpoints in each spline

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is SEQUENCER_FH_image_strip(FileHandler) and how is it used in Blender Python scripting?

assistant: # SEQUENCER_FH_image_strip(FileHandler)

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

*class* bpy.types.SEQUENCER_FH_image_strip(*FileHandler*)
:   *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 NodeClosureOutputItem(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NodeClosureOutputItem(bpy_struct)

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

*class* bpy.types.NodeClosureOutputItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0), (readonly)

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

    socket_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'`

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

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

assistant: # Axis Locking

[[image reference removed]](../../../../../_images/scene-layout_object_editing_transform_control_axis-locking_z-axis.png)

Axis locking.

This option limits the transformation to the specified axis.

[Transformations (translation/scale/rotation)](../introduction.html)
in *Object Mode* and *Edit Mode* (as well as extrusions in *Edit Mode*)
can be locked to a particular axis relative to
the current [transform orientation](../../../../../editors/3dview/controls/orientation.html).
By locking a transformation to a particular axis you are restricting transformations to a single dimension.
user: Provide the full official documentation entry for Edges, preserving all code examples.

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 Set Grease Pencil Softness Node in a Blender add-on or script – include code.

assistant: # Set Grease Pencil Softness Node

[image reference removed]

The *Set Grease Pencil Softness* node sets a stroke’s softness,
which controls how much a stroke’s edges fade out. Higher softness values create more transparent,
blurred edges, while lower values produce crisper, more defined strokes.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: Mirror around the individual origins.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_mirror_cursor-before.png>   Mesh before mirroring. | <../../../../_images/modeling_meshes_editing_mesh_mirror_individual-after.png>   Mesh after mirroring along the X axis. |

The next example shows mirroring around the *3D Cursor*, with the orientation set to *Local*:

Mirror around the 3D Cursor.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_mirror_cursor-before.png>   Mesh before mirroring. | <../../../../_images/modeling_meshes_editing_mesh_mirror_cursor-after.png>   Mesh after mirroring along the X axis using the 3D Cursor as the pivot point. |
user: Explain Example in complete detail according to the official Blender documentation.

assistant: Blur Effect samples (Samples: 8).

|  |  |  |  |
| --- | --- | --- | --- |
| <../../_images/grease-pencil_visual-effects_blur_factor-0.png>   Original Model. | <../../_images/grease-pencil_visual-effects_blur_factor-10.png>   Factor: 10, 10. | <../../_images/grease-pencil_visual-effects_blur_factor-50.png>   Factor: 50, 50. | <../../_images/grease-pencil_visual-effects_blur_factor-100.png>   Factor: 100, 100. |
user: What is Installing Git and Downloading the Repository and how is it used in Blender Python scripting?

assistant: In this guide, we will use the official Git client, though any Git client will do.

1. Download and install [Git](https://git-scm.com/download/win) for Windows.
2. Simply check out the Blender Manual’s repository using:

   ```
   cd ~
   git lfs install
   git clone https://projects.blender.org/blender/blender-manual.git
   ```
3. The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: Provide the full official documentation entry for Video Editing App Template, preserving all code examples.

assistant: # Video Editing App Template

The *Video Editing* app template provides a ready-to-use setup for a complete video editing workspace.

[image reference removed]

The default Video Editing app template.
user: Show practical ways to work with Set Attribute in a Blender add-on or script – include code.

assistant: Opens a pop-up window showing the name of the [active](../../glossary/index.html#term-Active) [attribute](../../glossary/index.html#term-Attribute)
as well as the value of that attribute for the selected points
From there, you assign a new value to a selected attribute across all selected points.

This tool is useful for uniformly setting attribute values such as size, color, or velocity across selected points.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.volume`](bpy.context.html#bpy.context.volume "bpy.context.volume") - [`BlendData.volumes`](bpy.types.BlendData.html#bpy.types.BlendData.volumes "bpy.types.BlendData.volumes") | - [`BlendDataVolumes.new`](bpy.types.BlendDataVolumes.html#bpy.types.BlendDataVolumes.new "bpy.types.BlendDataVolumes.new") - [`BlendDataVolumes.remove`](bpy.types.BlendDataVolumes.html#bpy.types.BlendDataVolumes.remove "bpy.types.BlendDataVolumes.remove") |
user: Give a detailed overview of Action Editor: syntax, arguments, return values, common patterns.

assistant: # Action Editor

While the *Dope Sheet* mode lets you work with keyframes of all animation in the
scene at the same time, the *Action Editor* mode focuses on the keyframes inside
a single [action](../../../animation/actions.html).

[image reference removed]

The Action Editor.

Actions are Blender’s container for animation data. Objects and other animatable
data-blocks reference actions to get animated by the animation data inside.
Data-blocks can reference one action as their *active action* and additional
actions through [Nonlinear Animation tracks](../../nla/tracks.html).
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Curve Index
:   The index of each curve within the geometry component.
    This can be used for deterministic indexing or pattern generation.

Curve ID
:   A stable unique ID for each curve.
    Unlike *Curve Index*, this value remains consistent even if curves are added or removed.

Length
:   The total length of each curve, measured along its evaluated spline.
    Useful for scaling effects or adjusting deformation strength based on hair length.

Direction
:   A normalized vector pointing from the root toward the tip of each curve.
    This represents the overall direction of the curve and can be used for
    orienting instances or driving direction-dependent effects.

Random
:   A random vector assigned per curve, based on the *Curve ID*.
    It provides consistent randomization between evaluations, allowing for
    reproducible but varied results across curves.

Surface UV
:   The UV coordinates on the surface mesh where each curve is attached.
    This is typically used for sampling textures, transferring color data,
    or controlling procedural effects based on surface location.
user: Describe Curve Handle Positions Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve Handle Positions Node

[image reference removed]

Gets the two handle positions of each control point in a Bézier spline.

You can use the [Set Handle Positions Node](../write/set_handle_positions.xhtml)
to change these positions.
user: What is ActionPoseMarkers(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ActionPoseMarkers(bpy_struct)

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

*class* bpy.types.ActionPoseMarkers(*bpy_struct*)
:   Collection of timeline markers

    active
    :   Active pose marker for this action

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

    active_index
    :   Index of active pose marker

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

    new(*name*)
    :   Add a pose marker to the action

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the marker (not unique)

        Returns:
        :   Newly created marker

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

    remove(*marker*)
    :   Remove a timeline marker

        Parameters:
        :   **marker** ([`TimelineMarker`](bpy.types.TimelineMarker.html#bpy.types.TimelineMarker "bpy.types.TimelineMarker"), (never None)) – Timeline marker to remove

    *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 Shader To RGB Node in a Blender add-on or script – include code.

assistant: # Shader To RGB Node

[image reference removed]

EEVEE Only

The Shader to RGB node is typically used for non-photorealistic rendering,
to apply additional effects on the output of BSDFs.
For example, a color ramp on the output of a diffuse BSDF can be used to create a flexible toon shader.

Using this conversion breaks the PBR pipeline and
thus makes the result unpredictable when used in combination with effects such as
ambient occlusion, contact shadows, soft shadows and screen space refraction.

Some effects require multiple samples to converge, and applying arbitrary changes to
noisy input may not convert to a smooth result.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Cache File
:   Data-block menu to select the Alembic or USD file.

File Path
:   Path to Alembic or USD file.

Object Path
:   The path to the Alembic or USD object inside the archive or stage.

Read Data
:   Controls which mesh data is imported from the cache file.
    You can selectively enable or disable the following:

    Vertices:
    :   Reads vertex positions and (if animated) deformations for each frame.

    Faces:
    :   Imports the mesh’s face topology and structure.

    UV:
    :   Loads UVs (texture coordinates) from the cache file.

    Color:
    :   Imports vertex color attributes from the cache file, if present.

    Attributes:
    :   Loads custom attributes (e.g., other data such as creases, custom normals, or generic attributes).

### Time

Sequence
:   Whether or not the cache is separated in a series of files.

Override Frame
:   Whether to use a custom frame for looking up data in the cache file,
    instead of using the current scene frame.

    The *Frame* value is the time to use for looking up the data in the cache file,
    or to determine which to use in a file sequence.

Frame Offset
:   Subtracted from the current frame to use for looking up the data in the cache file,
    or to determine which file to use in a file sequence.

### Velocity

Velocity Attribute
:   The name of the Alembic attribute used for generating motion blur data;
    by default, this is `.velocities` which is standard for most Alembic files.

Velocity Unit
:   Defines how the velocity vectors are interpreted with regard to time.

    Frame:
    :   The velocity unit was encoded in frames and does not need to be scale by scene FPS.

    Second:
    :   The velocity unit was encoded in seconds and needs to be scaled by the scene FPS (1 / FPS).

Velocity Scale
:   Multiplier used to control the magnitude of the velocity vector for time effects such as motion blur.
user: Give a detailed overview of Light Portals: syntax, arguments, return values, common patterns.

assistant: When rendering a daylight indoor scene where most of the light is coming in through a window
or door opening, it is difficult for the integrator to find its way to them.
To fix this, use [Light Portals](../light_settings.html#render-cycles-lights-area-portals).
You then will need to modify its shape to match that of the opening that you are trying to fill.

[image reference removed]

[image reference removed]
user: How do I use Duplicate Area into New Window in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates a new floating window containing a duplicate of the current editor area.
The new window is fully functional and part of the same Blender instance.

This is especially useful when working with multiple monitors.
user: Give a detailed overview of Backward Compatibility: syntax, arguments, return values, common patterns.

assistant: Opening older files and converting them for the current version of Blender is usually straight-forward.
It is expected to give very good and usable results.

There can be major feature changes, for which the backward compatibility will only be ensured for
a limited amount of time. For example the changes to the animation system that happened during the
Blender 2.5x project. This will never be less than a full major release cycle (i.e. two years at least).
user: Show practical ways to work with Mirror in a Blender add-on or script – include code.

assistant: [image reference removed]

The copied transform can be mirrored relative to an object or a [Bone](../../../glossary/index.html#term-Bone).
This requires choosing that object or bone first.

Object
:   This will just mirror relative to the chosen object.

    Choosing an [Armature](../../../glossary/index.html#term-Armature) object as mirror object will show the bone
    selector. You can use that to pick the bone to use as mirror. This will
    always use the named bone on that specific armature object.

Bone
:   When you choose *no mirror object* at all, you can still choose a *bone
    name*. This is used for mirroring against a bone in the *active armature*.
    This can be useful to mirror bone transforms relative to the ‘chest’ bone
    of the active character.

After pasting with ‘Paste Mirrored’, the mirror axes can be chosen in the
[redo panel](../../../interface/undo_redo.html#bpy-ops-screen-redo-last).
user: What is FFmpeg Audio Codecs and how is it used in Blender Python scripting?

assistant: No Audio:
:   For video-only encoding.

[AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding):
:   Advanced Audio Codec, a standardized, lossy compression and encoding scheme for digital audio.
    AAC generally achieves better sound quality than MP3 at similar bit rates.

[AC3](https://en.wikipedia.org/wiki/Dolby_Digital):
:   Audio Codec 3, an audio compression technology developed by Dolby Laboratories.

[FLAC](https://en.wikipedia.org/wiki/FLAC):
:   Free Lossless Audio Codec.
    Digital audio compressed by FLAC’s algorithm can typically be reduced to 50-60% of its original size.

[MP2](https://en.wikipedia.org/wiki/MPEG-1_Audio_Layer_II):
:   A lossy audio compression format.

[MP3](https://en.wikipedia.org/wiki/MP3):
:   A lossy audio compression format, widely used as final audio format.

[Opus](https://en.wikipedia.org/wiki/Opus_(audio_format)):
:   A lossy audio compression format, designed to encode speech or general audio
    and is intended to replace the *Vorbis* codec.

[PCM](https://en.wikipedia.org/wiki/PCM):
:   Pulse Code Modulation, a method used to digitally represent sampled analog signals.
    It is the standard form for digital audio in computers and various Blu-ray,
    Compact Disc and DVD formats, as well as other uses such as digital telephone systems.

[Vorbis](https://en.wikipedia.org/wiki/Vorbis):
:   An open-standard, highly-compressed format comparable to MP3 or AAC.
    Vorbis generally achieves better sound quality than MP3 at similar bit rates.
user: Describe Cache from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cache

The *Cache* is used to store preview frames in memory so they can be displayed much faster
during playback, rather than being re-rendered for each frame. This is especially useful for
maintaining smooth performance when editing or scrubbing through a sequence.

The total cache memory limit can be configured in the [System tab](../../../preferences/system.html)
of the Preferences.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`MovieTrackingPlaneMarkers.find_frame`](bpy.types.MovieTrackingPlaneMarkers.html#bpy.types.MovieTrackingPlaneMarkers.find_frame "bpy.types.MovieTrackingPlaneMarkers.find_frame") - [`MovieTrackingPlaneMarkers.insert_frame`](bpy.types.MovieTrackingPlaneMarkers.html#bpy.types.MovieTrackingPlaneMarkers.insert_frame "bpy.types.MovieTrackingPlaneMarkers.insert_frame") | - [`MovieTrackingPlaneTrack.markers`](bpy.types.MovieTrackingPlaneTrack.html#bpy.types.MovieTrackingPlaneTrack.markers "bpy.types.MovieTrackingPlaneTrack.markers") |
user: Give a detailed overview of Combining: syntax, arguments, return values, common patterns.

assistant: ### Cycles

The different render passes can be combined to produce the final image as follows:

[image reference removed]

### EEVEE

The passes can be combined to produce the final image as follows:

[image reference removed]
user: Describe FluidModifier(Modifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FluidModifier(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.FluidModifier(*Modifier*)
:   Fluid simulation modifier

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

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

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

    fluid_type
    :   - `NONE`
          None.
        - `DOMAIN`
          Domain – Container of the fluid simulation.
        - `FLOW`
          Flow – Add or remove fluid to a domain object.
        - `EFFECTOR`
          Effector – Deflect fluids and influence the fluid flow.

        Type:
        :   enum in [`'NONE'`, `'DOMAIN'`, `'FLOW'`, `'EFFECTOR'`], default `'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: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Instances
:   Standard geometry input.

Selection
:   The instances used to generate points. True values mean a point is created for the instance,
    false values mean the instance is skipped.

Position
:   Overrides the default position of generated point.

Radius
:   Controls the radius of the result points.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

An armature in Blender can be thought of as similar to the armature of a real skeleton,
and just like a real skeleton an armature can consist of many bones.
These bones can be moved around and anything that they are attached to or
associated with will move and deform in a similar way.

An “armature” is a type of object used for rigging.
A rig is the controls and strings that move a marionette (puppet).
Armature object borrows many ideas from real-world skeletons.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Seconds
:   Current scene time in seconds.

Frames
:   Current scene frame.
    As an input in geometry nodes, this output may also output non-round numbers,
    in order to support higher quality [motion blur](../../../../render/eevee/render_settings/motion_blur.html).
user: Describe Pivot Point from the Blender manual or Python API, including usage steps and snippets.

assistant: # Pivot Point

The Pivot Point is the point around which images are rotated and scaled.
It’s indicated by the position of the selected tool’s gizmo.

Bounding Box Center ()
:   Use the center of the rectangle that’s wrapped as tightly as possible around the selected
    images’ origin points.

Median Point ()
:   Use the averaged-out position of the selected images’ origin points.

2D Cursor ()
:   Use the location of the [2D Cursor](../sidebar.html#editors-sequencer-preview-2d-cursor),
    for when you want to specify the pivot point by hand.

Individual Origins ()
:   Rotate/scale each image around its own origin, rather than rotating/scaling
    all of them around the same single point like the other options do.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

Particle Instance modifier example.

The render above shows a single plane mesh object assigned to two different vertex groups
and each of those vertex groups is assigned to a separate and independent particle system,
with each particle system being assigned to a different Particle Instance modifier.
In the case shown the Particle Instance modifiers are added to a sphere and a cube.
See [example blend-file](https://archive.blender.org/wiki/2015/uploads/4/48/Manual_-_Modifiers_-_Particle_Instance_Modifiers_-_Split_Plane.blend).

[image reference removed]

Create Along Path example.

In this example, a single *Keyed* particle travels through four points (green planes),
on an elliptical path. The Particle Instance modifier is added to a cylinder object
and then associated with that *Keyed* particle system.

When the *Create Along Paths* is activated,
instead of the cylinder location just following the position of the particle,
the cylinder mesh is fitted to the shape of the path followed by the particle.
The mesh geometry of the object which is deformed
can have an impact on how well the deformation is carried out.
In the case of the cylinder, it has many loop cuts along its length so
that it can bend at those points to deform along the particle path.

The Particle Instance modifier *Create Along Paths* option works for hair (strand) particles
as well as with keyed particles. In this case, the mesh of the modifier will follow
the length and profile of the hair strands paths.
user: Describe Installation on Linux from the Blender manual or Python API, including usage steps and snippets.

assistant: # Installation on Linux

This guide covers the following topics:

1. [Installing Dependencies](#installing-dependencies)
2. [Downloading the Repository](#downloading-the-repository)
3. [Setting up the Build Environment](#setting-up-the-build-environment)
user: Explain Dt Layers Select Dst Items in complete detail according to the official Blender documentation.

assistant: # Dt Layers Select Dst Items

ACTIVE:
:   Active Layer.

    Affect active data layer of all targets.

NAME:
:   By Name.

    Match target data layers to affect by name.

INDEX:
:   By Order.

    Match target data layers to affect by order (indices).
user: Show practical ways to work with Using Cloth for Soft Bodies in a Blender add-on or script – include code.

assistant: [image reference removed]

Using cloth for soft bodies.

Cloth can also be used to simulate soft bodies.
It is for sure not its main purpose but it works nonetheless.
The example image uses standard *Rubber* material, no fancy settings,
just `Alt`-`A`.

Blend-file for the example image:
[Using Cloth for soft bodies](https://archive.blender.org/wiki/2015/index.php/File:Cloth-sb1.blend).
user: Explain Select Invert in complete detail according to the official Blender documentation.

assistant: Inverts the selection state of each point in the point cloud:

- Points that were selected become deselected.
- Points that were not selected become selected.

This operator is useful for quickly selecting the opposite subset of points in your current selection.
user: Give a detailed overview of Tabs: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Top: Horizontal Tab header in the Topbar.
Bottom: Vertical Tab header shows tab icons in the Properties.

Tabs are used to control overlapping sections in the user interface.
The content of only one Tab is visible at a time.
Tabs are listed in a *Tab header*, which can be horizontal or vertical.

### Switching/Cycling

Vertical tabs can be switched with `Ctrl`-`Wheel` from anywhere in the tab.
You can also cycle through tabs with `Ctrl`-`Tab` and
`Shift`-`Ctrl`-`Tab`, or press down `LMB` and move the mouse over the tab header icons.
Pressing `NumpadPeriod` scrolls to the active tab in case it is out of view.

Note, these shortcuts does not apply to Workspace tabs; see [Workspace controls](workspaces.xhtml#workspaces-controls).
user: Give a detailed overview of Edit Bones, Pose Bones, Bone… Bones: syntax, arguments, return values, common patterns.

assistant: Armature Bones in Blender have three distinct data structures that contain them.
If you are accessing the bones through one of them, you may not have access to the properties you really need.

### Edit Bones

`bpy.context.object.data.edit_bones` contains an edit bones;
to access them you must set the armature mode to Edit-Mode first (edit bones do not exist in Object or Pose-Mode).
Use these to create new bones, set their head/tail or roll, change their parenting relationships to other bones, etc.

Example using [`bpy.types.EditBone`](bpy.types.EditBone.html#bpy.types.EditBone "bpy.types.EditBone") in armature Edit-Mode
which is only possible in Edit-Mode:

```
>>> bpy.context.object.data.edit_bones["Bone"].head = Vector((1.0, 2.0, 3.0))
```

This will be empty outside of Edit-Mode:

```
>>> mybones = bpy.context.selected_editable_bones
```

Returns an edit bone only in Edit-Mode:

```
>>> bpy.context.active_bone
```

### Bones (Object-Mode)

`bpy.context.object.data.bones` contains bones.
These *live* in Object-Mode, and have various properties you can change,
note that the head and tail properties are read-only.

Example using [`bpy.types.Bone`](bpy.types.Bone.html#bpy.types.Bone "bpy.types.Bone") in Object or Pose-Mode
returning a bone (not an edit bone) outside of Edit-Mode:

```
>>> bpy.context.active_bone
```

This works, as with Blender the setting can be edited in any mode:

```
>>> bpy.context.object.data.bones["Bone"].use_deform = True
```

Accessible but read-only:

```
>>> tail = myobj.data.bones["Bone"].tail
```

### Pose Bones

`bpy.context.object.pose.bones` contains pose bones.
This is where animation data resides, i.e. animatable transformations
are applied to pose bones, as are constraints and IK-settings.

Examples using [`bpy.types.PoseBone`](bpy.types.PoseBone.html#bpy.types.PoseBone "bpy.types.PoseBone") in Object or Pose-Mode:

```
# Gets the name of the first constraint (if it exists).
bpy.context.object.pose.bones["Bone"].constraints[0].name

# Gets the last selected pose bone (Pose-Mode only).
bpy.context.active_pose_bone
```
user: Describe NodeTreeInterfaceSocketIntUnsigned(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketIntUnsigned(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketIntUnsigned(*NodeTreeInterfaceSocket*)
:   Integer number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Moves the selected nodes into the [active](../../../glossary/index.html#term-Active) group node.
To use, select a set of nodes, ending with the destination group node,
then, running the operation will move those nodes into that group.
The moved nodes are collected into a group of their own to preserve their connection context,
having their own group input and output nodes.
The group’s existing input and output nodes are updated with new sockets, if any, from the new nodes.
The node group must be edited to contain a single *Group Input* and a single *Group Output* node.
user: What is Usage and how is it used in Blender Python scripting?

assistant: ### With Hotkeys

Press `G`, `R` or `S` and then hold either `Ctrl`,
`Shift` or `Shift`-`Ctrl`.

### With the Transform Gizmo

Select the gizmo handle then while moving the mouse hold `Ctrl`, `Shift` or `Shift`-`Ctrl`
to activate precision control or snapping.
user: Describe Import Text Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Import Text Node

[image reference removed]

The *Import Text* node reads the contents of a plain text file and outputs it as a single string.
This can be useful in motion graphics or data-driven workflows where external text needs to be
processed or displayed.
user: How do I use Asset Previews in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Preview panel in the Asset Browser.

Preview images are typically generated automatically when you [mark a data-block as an asset](../files/asset_libraries/introduction.xhtml#bpy-ops-asset-mark). Objects are captured from their local -Y axis, while collections are captured from the global
-Y axis (as these don’t have a local axis).

If the auto-generated preview image isn’t sufficient, you can replace it by a custom one.

For previews of pose assets, see [Controlling the Look of Preview Images](../animation/armatures/posing/editing/pose_library.xhtml#poselib-preview-images).

### Screenshot Capture for Previews

In case a specific preview is needed, a fast way to create it is with a screenshot.
The operator to do so is located under the Preview popover, see [Capture Screenshot Preview](#bpy-ops-asset-screenshot-preview).
It is only possible to take screenshots for editable assets,
so assets in the [Current File](../files/asset_libraries/introduction.xhtml#asset-library-current-file)
and [Asset System Files](../files/asset_libraries/introduction.xhtml#asset-system-files).

Once started, you can click and drag a rectangular area over any part of Blender to capture a preview image.
During dragging it is possible to move the whole capture area or to unlock the aspect ratio.
See the shortcut help in the status bar for information on which keys to press.

On a re-run of the operator, the previously captured area will be remembered.
Simply clicking allows you to easily take the same screenshot again.