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

assistant: ### Creating a Slow-Motion Effect

Suppose you want to slow your strip down.
You need to affect the speed of the video clip without affecting the overall frame rate.
Select the clip and Add ‣ Effect ‣ Speed Control effect strip.

Choose the *Multiply* option in the Effect Strip panel in the Sidebar.
Set the Multiply Factor to be the factor by which you want to adjust the speed.
To cut the displayed speed by 50%, enter 0.5.
Now, a 275-frame clip will play at half speed, and thus display only the first 137 frames.

If you want the remaining frames to show in slow motion after the first set is displayed,
double the Length of the source strip
(since effects strip bounds are controlled by their source strips).
If you are using a speed factor other than 0.5 then use the formula:

`new_length = real_length / speed_factor`

That is it, set your render to animate (in this example) all 550 frames.

### Keyframing the Speed Control

[image reference removed]

Keyframing the Frame number.

To get even finer control over your clip timing, you can use curves!
While it is possible to keyframe the Multiply factor,
usually you want to keyframe the Frame number directly.

Choose the *Frame Number* option. You now have a Frame number field which you can keyframe.
If you want the strip to animate **at all** you will have to insert some keyframes,
otherwise it will look like a still. In most cases you will want to use the Graph editor view
to set the curve interpolation to Linear since the default Bézier will rarely be what you want.

### Changing Video Frame Rates

You can use the speed control to change the frame rate in frames per second (fps) of a video.
If you are rendering your video to a sequence set,
you can effectively increase or decrease the number of individual image files created,
by using a Multiply value less than or greater than one, respectively.

For example, if you captured a five-minute video at 30 fps and wanted to transfer that to film,
which runs at 24 fps, you would enter a Multiply Factor of 30/24, or 1.25
(and enable *Interpolation* frame blending to create a film blur effect).
Instead of producing `5 × 60 × 30 = 9000` frames,
Blender would produce `9000 / 1.25 = 7200 = 5 × 60 × 24` frames.
In this case, you set a *start* = 1 and *end* = 7200, set your Format output to `jpeg` 30fps,
and image files `0001.jpg` through `7200.jpg` would be rendered out,
but those images cover the entire 9000 frames. The image file `7200.jpg` is the same at frame 9000.
When you read those images back into your film blend-file at 24 fps, the strip will last exactly 5 minutes.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`GizmoGroup.gizmos`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.gizmos "bpy.types.GizmoGroup.gizmos") - [`GizmoGroup.invoke_prepare`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.invoke_prepare "bpy.types.GizmoGroup.invoke_prepare") | - [`Gizmos.new`](bpy.types.Gizmos.html#bpy.types.Gizmos.new "bpy.types.Gizmos.new") - [`Gizmos.remove`](bpy.types.Gizmos.html#bpy.types.Gizmos.remove "bpy.types.Gizmos.remove") |
user: Provide the full official documentation entry for Reload Library, preserving all code examples.

assistant: When the Outliner is in the *Blender File* [Display Mode](../../editors/outliner/interface.xhtml#bpy-types-spaceoutliner-display-mode),
you can right-click a linked blend-file and choose *Reload* to immediately update
the current blend-file with the latest version of the linked data-blocks,
without having to reopen the file.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: View Vector
:   A normalized vector, in camera space, from the camera to the shading point.

View Z Depth
:   The distance each pixel is away from the camera.

View Distance
:   Distance from the camera to the shading point.
user: Explain Main View in complete detail according to the official Blender documentation.

assistant: The X axis represents time, with the numbers 0/50/100/… being frame numbers.
The blue line is the *Playhead* indicating the current frame,
and the diamond shapes are *Keyframes*, points where you specified
a certain value for a certain property at a certain time.

### Adjusting the View

Panning is done by dragging `MMB`.

Zooming is done by dragging `Ctrl`-`MMB`, rolling the mouse `Wheel`,
or pressing `NumpadMinus`/`NumpadPlus`.

You can also use the scrollbars located at the bottom and the right of the editor.

### Frame Range

The *Frame Range* determines the length of the scene’s animation.
By default, it’s set to start at frame 1 and end at frame 250.
You can change this using the Start/End inputs in the Timeline header,
or in the [Output Properties](../render/output/properties/frame_range.xhtml).

### Keyframes

By default, the timeline only shows keyframes for selected items.
You can make it show all keyframes by unchecking
View ‣ Only Show Selected.

You can click a keyframe to select it (and deselect all others),
or click it while holding `Shift` to add it to the selection
(or remove it if it was already selected). You can also drag a box
to select multiple keyframes in one go.

To move the selected keyframes, simply drag one of them. Alternatively,
you can press `G`, move the mouse, and click `LMB` to confirm
(or `RMB` to cancel). You can also press `S` to scale the keyframes
in relation to the Playhead.

### Markers

See the [Markers page](../animation/markers.xhtml) for more information.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The proverb “A good start is half the battle”, certainly applies to video editing.
Setting up your *work environment* and *project* to your needs is key to success.
In setting up your video project, you have to distinguish between:

- Work Environment related settings and activities:

  These settings apply to all of your projects and are set at “Blender level”; for example the installation
  of add-ons. In fact, they can also influence your non-video editing projects.
  Most of these settings remain more or less stable throughout your projects and should probably only set once.
- Project related settings and activities:

  These settings vary from project to project and are very specific for your project;
  for example the output media format. For each new project, you have to evaluate these settings and activities.

Of course, many settings and activities occur at both levels.
For example, automatic proxies can be enabled globally but changed on a per project or even strip basis.
The layout of the Video Editing Workspace is defined at Blender level but can be tweaked per project.
user: Show practical ways to work with GeometryNodeSetCurveRadius(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeSetCurveRadius(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.GeometryNodeSetCurveRadius(*GeometryNode*)
:   Set the radius of the curve at each control point

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Selecting Bones

You can select and edit bones of armatures in *Edit Mode* and in *Pose Mode*.
Here, we will see how to select bones in *Edit Mode*.
Selecting bones in *Pose Mode* is similar to selecting in *Edit Mode*
with a few specific differences that will be detailed in
the [posing part](../posing/selecting.html).

Similar to [vertex/edge selection](../../../modeling/meshes/selecting/introduction.html) in meshes,
there are two ways to select whole bones in *Edit Mode*:

1. Directly, by selecting the bone’s body.
2. Selecting both of its joints (root and tip).

This is an important point to understand,
because selecting bones’ joints only might lead to non-obvious behavior,
with respect to which bone you actually select.

Note that unlike the mesh display type, the armature display type has no effect on selection behavior.
In other words, you can select a bone’s joint or body the same way regardless of
the bone visualization chosen.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Text objects contain some text, and are in the same object type family as curves and surfaces ones,
as fonts are vector data (they are made of curves).

Blender uses a “Font System” to manage mapping letter codes to geometry representing them in the 3D Viewport.
This font system has its own *built-in* font, but it can use external fonts too,
including *PostScript Type 1*, *OpenType* and *TrueType* fonts.
And moreover, it can use any objects existing in the current blend-file as letters.

[image reference removed]

An example of an extruded text.

Text objects allow you to create and render 2D or 3D text,
with various advanced layout options, like justifying and frames.
By default, letters are just flat filled surfaces, exactly like any closed 2D curve.
But, just like curves, you can extrude them,
and apply [modifiers](../modifiers/introduction.xhtml) to them
(e.g. to make them [follow a curve](../modifiers/deform/curve.xhtml)).

Text in Blender can be laid out in some relatively advanced ways,
defining columns or blocks of text, using different alignments, and so on.

Those features are similar in concept to what you can find in DTP software
(like [Scribus](https://www.scribus.net/)), although at a very basic level currently.
user: Give a detailed overview of Snapping: syntax, arguments, return values, common patterns.

assistant: Snapping aligns the position and size of nodes to the background grid.
This feature allows nodes to snap to a grid, ensuring that node layouts remain clean and visually aligned.
Snapping can be toggling the snap icon (/) in the editor’s headers
or toggled temporarily while [transforming](editing.xhtml#nodes-editing-transform) nodes by holding `Ctrl`.
user: Explain File Path Foreach Flag Items in complete detail according to the official Blender documentation.

assistant: # File Path Foreach Flag Items

SKIP_LINKED:
:   Skip Linked.

    Skip paths of linked IDs.

SKIP_PACKED:
:   Skip Packed.

    Skip paths when their matching data is packed.

RESOLVE_TOKEN:
:   Resolve Token.

    Resolve tokens within a virtual filepath to a single, concrete, filepath. Currently only used for UDIM tiles.

SKIP_WEAK_REFERENCES:
:   Skip Weak References.

    Skip weak reference paths. Those paths are typically ‘nice to have’ extra information, but are not used as actual source of data by the current .blend file.

SKIP_MULTIFILE:
:   Skip Multi-file.

    Skip paths where a single dir is used with an array of files, eg. sequence strip images or point-caches. In this case only the first file path is processed. This is needed for directory manipulation callbacks which might otherwise modify the same directory multiple times.

RELOAD_EDITED:
:   Reload Edited.

    Reload data when the path is edited.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Count
:   Number of vertices on the line.

Resolution
:   Length of individual edges.
    The node tries to fit as many vertices as possible between the start and end point.
    The exact end point might not be hit.
    This is only available when the mode is set to *End Points* and the count mode is set to *Resolution*.

Start Location
:   Position of the first vertex.

Offset
:   Controls the direction of the line and distance between the vertices.
    This is only available when the mode is set to *Offset*.

End Location
:   Position of the last vertex.
    This is only available when the mode is set to *End Points*.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Matrix
:   The inverted matrix.

Invertible
:   Returns whether the matrix could be inverted.
    This can be false when a transformation matrix has a scale of zero, for example.
    See [Invertible matrix](https://en.wikipedia.org/wiki/Invertible_matrix) for more information.
user: Show practical ways to work with Set Handle Type in a Blender add-on or script – include code.

assistant: Handle types are a property of [Bézier curves](../structure.xhtml#curve-bezier) and
can be used to alter features of the curve.
For example, switching to *Vector handles* can be used to create curves with sharp corners.
Read the [Bézier curves](../structure.xhtml#curve-bezier-handle-type) page for more details.

Toggle Free/Align
:   Additionally, this operator can be used to toggle between Free and Aligned handle types.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Curve Index
:   The index of the input curve.

Weights
:   Values used to sort the curve’s control points.
    By default the control points are sorted by index, so the control points with the smallest indices come first.

Sort Index
:   Which of the sorted control points to use for the *Point Index* output. If the value is larger than
    the total number of control points, it will wrap around to the beginning.
user: Explain Anonymous Attributes in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The *Normal* and *Rotation* outputs are examples of attribute fields,
which refer to an attribute stored on a geometry.

An anonymous attribute is a set of generic data stored on a geometry that doesn’t have a name.
Usually, attributes exposed in Blender’s interface all have names. However,
in geometry nodes, attributes can be passed around with node sockets.
In these cases, an *Attribute Field* output is created, which is used by
nodes to find attribute data in an input geometry.

Anonymous attributes are still stored on the geometry like other attributes, and they are even
automatically interpolated when the geometry changes with other nodes, except for a few cases.
So generally, if the node link is still accessible, the attribute it references will be available
too. However, anonymous attributes cannot be connected to a completely separate geometry
that was created from a different source. To transfer attributes between separate geometries,
the [Sample Index Node](geometry/sample/sample_index.xhtml) or other similar nodes like the
[Sample Nearest Surface Node](mesh/sample/sample_nearest_surface.xhtml) can be used.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`DynamicPaintCanvasSettings.canvas_surfaces`](bpy.types.DynamicPaintCanvasSettings.html#bpy.types.DynamicPaintCanvasSettings.canvas_surfaces "bpy.types.DynamicPaintCanvasSettings.canvas_surfaces") | - [`DynamicPaintSurfaces.active`](bpy.types.DynamicPaintSurfaces.html#bpy.types.DynamicPaintSurfaces.active "bpy.types.DynamicPaintSurfaces.active") |
user: Give a detailed overview of Cycles Operators: syntax, arguments, return values, common patterns.

assistant: # Cycles Operators

bpy.ops.cycles.denoise_animation(*\**, *input_filepath=''*, *output_filepath=''*)
:   Denoise rendered animation sequence using current scene and view layer settings. Requires denoising data passes and output to OpenEXR multilayer files

    Parameters:
    :   - **input_filepath** (*string**,* *(**optional**,* *never None**)*) – Input Filepath, File path for image to denoise. If not specified, uses the render file path and frame range from the scene
        - **output_filepath** (*string**,* *(**optional**,* *never None**)*) – Output Filepath, If not specified, renders will be denoised in-place

    File:
    :   [addons_core/cycles/operators.py:49](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/cycles/operators.py#L49)

bpy.ops.cycles.merge_images(*\**, *input_filepath1=''*, *input_filepath2=''*, *output_filepath=''*)
:   Combine OpenEXR multi-layer images rendered with different sample ranges into one image with reduced noise

    Parameters:
    :   - **input_filepath1** (*string**,* *(**optional**,* *never None**)*) – Input Filepath, File path for image to merge
        - **input_filepath2** (*string**,* *(**optional**,* *never None**)*) – Input Filepath, File path for image to merge
        - **output_filepath** (*string**,* *(**optional**,* *never None**)*) – Output Filepath, File path for merged image

    File:
    :   [addons_core/cycles/operators.py:137](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/cycles/operators.py#L137)

bpy.ops.cycles.use_shading_nodes()
:   Enable nodes on a light

    File:
    :   [addons_core/cycles/operators.py:23](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/cycles/operators.py#L23)
user: Describe Disconnecting Sockets from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Interactively

Drag the link away from its input socket and let it go, keeping it unconnected.

### Mute Links

Activate the menu item or hold the key combination,
then draw a line across one or more links to mute/unmute them.
A muted link acts as though it’s no longer there; this also means the input fields
for specifying fixed values become visible again.

When muting links on the input side of a [reroute node](types/layout/reroute.xhtml),
the links on its output side will be muted too.

[image reference removed]

### Cut Links

Activate the menu item or hold the key combination,
then draw a line across one or more links to delete them.

Detach Links `Alt`-`LMB` drag
:   Use Detach Links to cut all the links attached to the selected nodes
    and move the nodes to a new location.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: This example shows you how setup a *Path Animation*.

1. Add an object you want to animate and a path along which this object will move.
   In this example it’s the *Monkey* and the *Bézier Circle*.
2. To parent the monkey to the Bézier circle, first select the monkey then the curve
   (so that the curve is the active object), press `Ctrl`-`P` and select *Follow Path*.
   It will automatically animate *Evaluation Time* and activate *Follow* option
   in the *Path Animation* panel.
3. Select the monkey and
   [Clear Origin](../../../scene_layout/object/editing/clear.html) to reset its offset.
4. You can change the orientation of the monkey by changing
   the [Tracking Axis](../../../scene_layout/object/properties/relations.html).

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_properties_path-animation_example-1.png   Monkey parented to the Bézier Circle. | ../../../_images/modeling_curves_properties_path-animation_example-2.png   The final result. |
user: Describe Enabling Add-on from the Blender manual or Python API, including usage steps and snippets.

assistant: 1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “Node Wrangler” and check the *Enable Add-on* checkbox.
user: How do I use Image Sequence in Blender? Include parameters, examples, warnings and best practices.

assistant: In the case of (numbered) image sequences
(e.g. `*-0001.jpg`, `*-0002.jpg`, `*-0003.jpg`, etc, of any image format), you have a choice:

Range
:   Navigate into the directory and `LMB` click and drag over a range of names to highlight multiple files.
    You can page down and continue `Shift`-`LMB` click-dragging to add more to the selection.

Batch
:   `Shift`-`LMB` click selected non-related stills for batch processing; each image will be one frame,
    in sort order, and can be a mix of file types (`jpg`, `png`, `exr`, etc.).

All
:   Press `A` to select/deselect all files in the directory.
user: Provide the full official documentation entry for Elaborate Movements, preserving all code examples.

assistant: When the footage builds on elaborate intended movement of the camera,
the process of stabilization becomes more involved –
especially when there is a shift in the main area of interest within the shot.
When working with many tracks and fine-grained animation,
it is easy to get into a situation where additional manipulations actually decrease the quality,
while it might be hard to spot and locate the root cause of problems.
Recommendation is to proceed systematically, starting from the general outline down to tweaking of specific aspects.

1. Understand the nature of the movements in the shot, both the intended and the accidental.
2. Track some relevant features for location.
3. Establish the basic location stabilization.
   This includes the decision, which feature to use for what segment of the shot.
   Work with the track weights to get an overall consistent movement of the weight center,
   in accordance with the inherent focus of the shot.
4. Define the panning movements of the virtual camera (through animation of the *Expected Position* parameter).
5. Add tracking for rotation and zoom stabilization.
6. Fine-tuning pass:

   Break down the whole duration of the shot into logical segments to define the intended camera movement.
   Then refine those segments incrementally step-by-step, until the overall result looks satisfactory…
user: What is Startup and how is it used in Blender Python scripting?

assistant: # Startup

If Blender fails to start, there are a few common causes to check for:

- See if your computer meets the [minimum requirements](https://www.blender.org/download/requirements/).
- Confirm that your graphics card is supported and that the drivers are up to date (see
  [Troubleshooting Graphics Hardware](gpu/index.xhtml)).
- Make sure any antivirus software is not preventing Blender from starting.
- Ensure that you have appropriate user permissions on the computer.

If you cannot find a solution to your problem here, try asking the [community](../getting_started/about/community.xhtml)
for help.
user: Give a detailed overview of Subdivide: syntax, arguments, return values, common patterns.

assistant: # Subdivide

You can subdivide bones, to get two or more bones where there was just one bone.
The tool will subdivide all selected bones, preserving the existing relationships:
the bones created from a subdivision always form a connected chain of bones.

To create an arbitrary number of bones from each selected bone
in the Subdivide Multi [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.

Number of Cuts
:   Specifies the number of cuts. As in mesh editing,
    if you set *n* cuts, you will get *n* + 1 bones for each selected bone.

Subdivision example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_subdivide_example-1.png   An armature with one selected bone, just before multi-subdivision. | ../../../../_images/animation_armatures_bones_editing_subdivide_example-2.png   The selected bone has been “cut” two times, giving three sub-bones. |
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`ToolSettings.vertex_paint`](bpy.types.ToolSettings.html#bpy.types.ToolSettings.vertex_paint "bpy.types.ToolSettings.vertex_paint") | - [`ToolSettings.weight_paint`](bpy.types.ToolSettings.html#bpy.types.ToolSettings.weight_paint "bpy.types.ToolSettings.weight_paint") |
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image/Color
:   Standard color input.

Factor
:   Controls the amount of influence the node exerts on the image.

Black Level Compositor Only
:   Defines the input color that should be mapped to black.

White Level Compositor Only
:   Defines the input color that should be mapped to white.
user: Explain MaterialSlot(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # MaterialSlot(bpy_struct)

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

*class* bpy.types.MaterialSlot(*bpy_struct*)
:   Material slot in an object

    link
    :   Link material to object or the object’s data

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

    material
    :   Material data-block used by this material slot

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

    name
    :   Material slot name

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

    slot_index
    :   Type:
        :   int in [-inf, inf], default 0, (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 Outputs: syntax, arguments, return values, common patterns.

assistant: Image
:   A colored output of the input image with the matte applied to only include selected layers.

Matte
:   A black-and-white alpha mask of the all the selected crypto layers.

Pick
:   A colored representation of the Cryptomatte pass which can be used
    with a Viewer node to select which crypto passes are used to create the matte image.
user: How do I use Lock/Mute in Blender? Include parameters, examples, warnings and best practices.

assistant: Lock Strips `Ctrl`-`H`
:   Disables the strip from being transformed.

Unlock Strips `Ctrl`-`Alt`-`H`
:   Enables disabled strips allowing them to be transformed.

Mute/Unmute Strips `H`, `Alt`-`H`
:   Mute or unmute the selected strips.

Mute/Unmute Deselected Strips `Shift`-`H`, `Shift`-`Alt`-`H`
:   Mute or unmute all strips but the selected.
user: What is Example and how is it used in Blender Python scripting?

assistant: The Filter node has eight modes, shown here.

|  |  |
| --- | --- |
| ../../../_images/compositing_types_filter_filter-node_example-1-original.png   Original image. | ../../../_images/compositing_types_filter_filter-node_example-2-soften.png   Soften. |
| ../../../_images/compositing_types_filter_filter-node_example-3-box-sharpen.png   Box Sharpen. | ../../../_images/compositing_types_filter_filter-node_example-4-diamond-sharpen.png   Diamond Sharpen. |
| ../../../_images/compositing_types_filter_filter-node_example-5-laplace.png   Laplace. | ../../../_images/compositing_types_filter_filter-node_example-6-sobel.png   Sobel. |
| ../../../_images/compositing_types_filter_filter-node_example-7-prewitt.png   Prewitt. | ../../../_images/compositing_types_filter_filter-node_example-8-kirsch.png   Kirsch. |
| ../../../_images/compositing_types_filter_filter-node_example-9-shadow.png   Shadow. |  |
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: After the tool is run, these options are available in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.

Error
:   Error distance in object units. This can be seen similar to a subdivision rate for the curve.
    Lower values give a result that is closer to the drawing stroke while higher values give more smoothed results.

Fit Method
:   Refit:
    :   Incrementally refits the curve (gives best results).

    Split:
    :   Splits the curve until the tolerance is met (gives a better drawing performance).

Corner Angle
:   Any angles above this are considered corners.

Cyclic
:   Toggles whether or not the curve is [Cyclic](../../../glossary/index.html#term-Cyclic).
user: Provide the full official documentation entry for Make Meta, preserving all code examples.

assistant: Groups the selected NLA-strips into a meta strip.

|  |  |
| --- | --- |
| <../../../_images/editors_nla_strips_meta1.png>   Select two or more strips. | <../../../_images/editors_nla_strips_meta2.png>   Combine them into a meta strip. |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Limits
:   Angular
    :   X Angle, Y Angle, Z Angle
        :   Enables/disables limit rotation around X, Y or Z axis respectively.

            Lower
            :   Lower limit of rotation for X, Y or Z axis respectively.

            Upper
            :   Upper limit of rotation for X, Y or Z axis respectively.

    Linear
    :   X Axis, Y Axis, Z Axis
        :   Enables/disables limit translation on X, Y or Z axis respectively.

            Lower
            :   Lower limit of translation for X, Y or Z axis respectively.

            Upper
            :   Upper limit of translation for X, Y or Z axis respectively.
user: What is Grease Pencil Object Modes and how is it used in Blender Python scripting?

assistant: # Grease Pencil Object Modes

Object Modes allow editing different aspects of Grease Pencil objects.
These modes are specifically tailored to the Grease Pencil object,
unlike the more general modes, which work for other object types
(with the exception of object mode which is the same for all objects).

Draw Mode is where new strokes are created.
Strokes are directly sketched on a canvas, using different tools and brushes.

Sculpt Mode can be used to deform and shape existing strokes more organically.
Strokes can be smoothed, deformed, or reshaped, adding fluidity and dynamism to drawings.

Edit Mode allows modifying individual strokes and points of Grease Pencil objects.
This mode is ideal for fine-tuning linework, adjusting shapes, and refining details.

Vertex Paint Mode allows adding color the vertices of strokes directly.
This mode is useful for adding shading, gradients, or detailed color effects
providing finer control over the drawing’s appearance.

Weight Paint Mode allows assigning vertex weights to strokes.
This is crucial for rigging and animating characters, ensuring smooth,
and precise deformations based on the painted weights.

This mode allows working with the entire Grease Pencil object as a whole.
It’s used for overall transformations and managing the placement of the object within the scene.
user: Show practical ways to work with Mesh Filter in a Blender add-on or script – include code.

assistant: # Mesh Filter

Applies a deformation to all vertices in the mesh at the same time.
Masking, auto-masking and visibility will be taken into account.

To use this tool, click and drag away from left to right
or from right to left for a negative effect.
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.xhtml).
user: How do I use Motion Paths in Blender? Include parameters, examples, warnings and best practices.

assistant: # Motion Paths

[image reference removed]

An animated cube with its motion path displayed.

The Motion Paths tool allows you to visualize the motion of points as paths over a series of frames.
These points can be object origins and bone joints.

To create or remove motion paths, it is necessary to first select the bones. Then:

1. To show the paths (or update them, if needed), click on the *Calculate Path* button.
2. To hide the paths, click on the *Clear Paths* button.

The paths are shown in red for the section in the past and green for the section in the future.
These colors follow the user preference options “Before Current Frame” and “After Current Frame”,
which can be found in the 3D Viewport section.
Each frame is displayed by a small dot on the paths.

The paths are automatically updated when you edit your poses/keyframes,
and they are also active during animation playback. Playing the animation
affects the paths only when using the *Around Frame* type.
user: Explain ActionChannelbag(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ActionChannelbag(bpy_struct)

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

*class* bpy.types.ActionChannelbag(*bpy_struct*)
:   Collection of animation channels, typically associated with an action slot

    fcurves
    :   The individual F-Curves that animate the slot

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

    groups
    :   Groupings of F-Curves for display purposes, in e.g. the dopesheet and graph editor

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

    slot
    :   The Slot that the Channelbag’s animation data is for

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

    slot_handle
    :   Type:
        :   int in [-inf, inf], default 0, (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: What is System and how is it used in Blender Python scripting?

assistant: # System

The *System* section allows you to set graphics card options, memory limits & sound settings.

If your hardware does not support some of the options described on this page,
then they will either not be displayed or be corrected on startup.

[image reference removed]

Preferences System section.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Standard color input.

Space
:   Coordinate Space to scale relative to.

    Relative:
    :   Percentage values relative to the dimensions of the image input.

    Absolute:
    :   Size of an image by using absolute pixel values.

    Scene Size:
    :   Sizes an image to the size of the final render resolution for the scene.
        For example, rendering a scene at the standard 1080p resolution but setting the render percentage at 50%,
        will produce a 1080p image with the scene scaled down 50% and leaving the rest of the image as alpha.

    Render Size:
    :   Image dimensions set in the Render panel.

Frame Type Render Size
:   How the image fits in the camera frame.

    Stretch:
    :   Distorts the image so that it fits into the render size.

    Fit:
    :   Scales the image until the bigger axis “fits” into the render size.

    Crop:
    :   Cuts the image so that it is the same aspect ratio as the render size.

X, Y
:   Scale in the axis directions, only available if *Space* is set to *Relative* or *Absolute*.

### Sampling

Interpolation
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: What is AttributeGroupPointCloud(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AttributeGroupPointCloud(bpy_struct)

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

*class* bpy.types.AttributeGroupPointCloud(*bpy_struct*)
:   Group of geometry attributes

    active
    :   Active attribute

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

    active_index
    :   Active attribute index or -1 when none are active

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

    new(*name*, *type*, *domain*)
    :   Add attribute to geometry

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name, Name of geometry attribute
            - **type** (enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items)) – Type, Attribute type
            - **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   New geometry attribute

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

    remove(*attribute*)
    :   Remove attribute from geometry

        Parameters:
        :   **attribute** ([`Attribute`](bpy.types.Attribute.html#bpy.types.Attribute "bpy.types.Attribute"), (never None)) – Geometry Attribute

    domain_size(*domain*)
    :   Get the size of a given domain

        Parameters:
        :   **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   Size, Size of the domain

        Return type:
        :   int in [0, inf]

    *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 Combine Spherical Node in complete detail according to the official Blender documentation.

assistant: # Combine Spherical Node

[image reference removed]

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

Spherical coordinates represent a point in 3D space by its distance from the origin,
horizontal rotation, and vertical inclination, which can be useful for constructing
radial or rotational patterns and generating coordinates on a sphere.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Data Type
:   Float:
    :   The output will be a single floating-point value.

    Vector:
    :   The output will be a vector of three floating-point values.
        All calculations are elementwise.

Domain
:   The [attribute domain](../attributes_reference.xhtml#attribute-domains) used for the statistics
    and to evaluate the input *Attribute* field on.
user: Explain CompositorNodeCryptomatte(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeCryptomatte(CompositorNode)

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

*class* bpy.types.CompositorNodeCryptomatte(*CompositorNode*)
:   Deprecated. Use Cryptomatte Node instead

    add
    :   Add object or material to matte, by picking a color from the Pick output

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [-inf, inf], default (1.0, 1.0, 1.0)

    matte_id
    :   List of object and material crypto IDs to include in matte

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

    remove
    :   Remove object or material from matte, by picking a color from the Pick output

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [-inf, inf], default (1.0, 1.0, 1.0)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use FunctionNodeInputBool(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeInputBool(FunctionNode)

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

*class* bpy.types.FunctionNodeInputBool(*FunctionNode*)
:   Provide a True/False value that can be connected to other nodes in the tree

    boolean
    :   Input value used for unconnected socket

        Type:
        :   [boolean](#bpy.types.FunctionNodeInputBool.boolean "bpy.types.FunctionNodeInputBool.boolean"), default False

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

        Returns:
        :   Result

        Return type:
        :   [boolean](#bpy.types.FunctionNodeInputBool.boolean "bpy.types.FunctionNodeInputBool.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