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

assistant: Displays a popover window that allows editing the custom expression and input variables
of the driver without opening the full *Drivers Editor*.

Many drivers don’t use their [F-Curve](../../editors/graph_editor/fcurves/introduction.html)
component, so this reduced interface is sufficient.
user: Explain Filtering in complete detail according to the official Blender documentation.

assistant: Below the preset list, you can filter the list of operations so you can quickly find the one you need.

Filter Type
:   Name:
    :   Filter the operations by their name (such as `New File`).

    Key Binding:
    :   Filter the operations by their currently assigned shortcut (such as `ctrl n`).

Search
:   The text to search (leave blank to show all operations).
user: Give a detailed overview of GPU Matrix Utilities (gpu.matrix): syntax, arguments, return values, common patterns.

assistant: # GPU Matrix Utilities (gpu.matrix)

This module provides access to the matrix stack.

gpu.matrix.get_model_view_matrix()
:   Return a copy of the model-view matrix.

    Returns:
    :   A 4x4 view matrix.

    Return type:
    :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix")

gpu.matrix.get_normal_matrix()
:   Return a copy of the normal matrix.

    Returns:
    :   A 3x3 normal matrix.

    Return type:
    :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix")

gpu.matrix.get_projection_matrix()
:   Return a copy of the projection matrix.

    Returns:
    :   A 4x4 projection matrix.

    Return type:
    :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix")

gpu.matrix.load_identity()
:   Load an identity matrix into the stack.

gpu.matrix.load_matrix(*matrix*)
:   Load a matrix into the stack.

    Parameters:
    :   **matrix** ([`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix")) – A 4x4 matrix.

gpu.matrix.load_projection_matrix(*matrix*)
:   Load a projection matrix into the stack.

    Parameters:
    :   **matrix** ([`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix")) – A 4x4 matrix.

gpu.matrix.multiply_matrix(*matrix*)
:   Multiply the current stack matrix.

    Parameters:
    :   **matrix** ([`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix")) – A 4x4 matrix.

gpu.matrix.pop()
:   Remove the last model-view matrix from the stack.

gpu.matrix.pop_projection()
:   Remove the last projection matrix from the stack.

gpu.matrix.push()
:   Add to the model-view matrix stack.

gpu.matrix.push_pop()
:   Context manager to ensure balanced push/pop calls, even in the case of an error.

gpu.matrix.push_pop_projection()
:   Context manager to ensure balanced push/pop calls, even in the case of an error.

gpu.matrix.push_projection()
:   Add to the projection matrix stack.

gpu.matrix.reset()
:   Empty stack and set to identity.

gpu.matrix.scale(*scale*)
:   Scale the current stack matrix.

    Parameters:
    :   **scale** (*Sequence**[**float**]*) – Scale the current stack matrix with 2 or 3 floats.

gpu.matrix.scale_uniform(*scale*)
:   Parameters:
    :   **scale** (*float*) – Scale the current stack matrix.

gpu.matrix.translate(*offset*)
:   Scale the current stack matrix.

    Parameters:
    :   **offset** (*Sequence**[**float**]*) – Translate the current stack matrix with 2 or 3 floats.
user: How do I use Linked in Blender? Include parameters, examples, warnings and best practices.

assistant: Select geometry connected to already selected elements.
This is often useful when a mesh has disconnected, overlapping parts,
where isolating it any other way would be tedious.
To give more control, you can also enable delimiters in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel,
so the selection is constrained by seams, sharp edges, materials or UV islands.

With *Pick Linked* you can also select connected geometry directly under the cursor,
using the `L` shortcut to select or `Shift`-`L` to deselect linked.
This works differently in that it uses the geometry under the cursor instead of the existing selection.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The node can be used to make overflowing text boxes. Here, the text that does not fit into
the first node’s fixed-size text box is passed to a separate *String to Curves* node,
then scaled with a *Scale to Fit* node.
user: Give a detailed overview of Volumetrics: syntax, arguments, return values, common patterns.

assistant: - Only single scattering is supported.
- Volumetrics are rendered only for the camera “rays”. They don’t appear in reflections/refractions and probes.
- Volumetric shadowing only work in volumetrics. They won’t cast shadows onto solid objects in the scene.
- Volumetric shadowing only work for volumes inside the view frustum.
user: Explain Selecting in complete detail according to the official Blender documentation.

assistant: Blender has two main selection modes: left-click select and right-click select.
See the [Select with Mouse Button](../../editors/preferences/keymap.html#keymap-blender-default-prefs-select-with) preference.

While left-click select is the default as it’s the most common in other applications,
right-click select does have its advantages.
See: [Learn the benefits of right-click select](https://vimeo.com/76335056).
user: Describe Geometry Input Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Geometry Input Node

[image reference removed]

The *Geometry Input* node provides geometry from an external object, collection,
or input connection to be used inside a node group.
It is useful for referencing other geometry data or injecting custom geometry
into a procedural setup.
user: Show practical ways to work with Self Object Node in a Blender add-on or script – include code.

assistant: # Self Object Node

[image reference removed]

The *Self Object* node outputs the object that contains the geometry nodes modifier
currently being executed. This can be used to retrieve the original transforms.

When evaluated in the [Tool context](../../tools.html#tool-context), this node returns the Active object.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Island Index
:   The index of each vertex’s island. Indices are decided based on the
    lowest vertex index contained in each island.

Island Count
:   The total number of mesh islands. This is a single value, and does not vary per element.
user: How do I use SimpleDeformModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SimpleDeformModifier(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.SimpleDeformModifier(*Modifier*)
:   Simple deformation modifier to apply effects such as twisting and bending

    angle
    :   Angle of deformation

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

    deform_axis
    :   Deform around local axis

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

    deform_method
    :   - `TWIST`
          Twist – Rotate around the Z axis of the modifier space.
        - `BEND`
          Bend – Bend the mesh over the Z axis of the modifier space.
        - `TAPER`
          Taper – Linearly scale along Z axis of the modifier space.
        - `STRETCH`
          Stretch – Stretch the object along the Z axis of the modifier space.

        Type:
        :   enum in [`'TWIST'`, `'BEND'`, `'TAPER'`, `'STRETCH'`], default `'TWIST'`

    factor
    :   Amount to deform object

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

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    limits
    :   Lower/Upper limits for deform

        Type:
        :   float array of 2 items in [0, 1], default (0.0, 1.0)

    lock_x
    :   Do not allow deformation along the X axis

        Type:
        :   boolean, default False

    lock_y
    :   Do not allow deformation along the Y axis

        Type:
        :   boolean, default False

    lock_z
    :   Do not allow deformation along the Z axis

        Type:
        :   boolean, default False

    origin
    :   Offset the origin and orientation of the deformation

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

    vertex_group
    :   Vertex group name

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Attribute Domain Without Corner Items and how is it used in Blender Python scripting?

assistant: # Attribute Domain Without Corner Items

POINT:
:   Point.

    Attribute on point.

EDGE:
:   Edge.

    Attribute on mesh edge.

FACE:
:   Face.

    Attribute on mesh faces.

CURVE:
:   Spline.

    Attribute on spline.

INSTANCE:
:   Instance.

    Attribute on instance.

LAYER:
:   Layer.

    Attribute on Grease Pencil layer.
user: What is Duplicate Area into New Window and how is it used in Blender Python scripting?

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: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   The geometry input to the node group, used when the node is connected to another geometry socket.

Input Type
:   Determines the source type of the geometry.

    Object:
    :   Uses a single object as the geometry source.

    Collection:
    :   Uses all objects within a collection as the geometry source.

Object / Collection
:   Specifies the object or collection to use as the geometry input, depending on the selected *Input Type*.

Relative Space
:   When enabled, the input geometry is transformed relative to the modifier or main geometry’s local space,
    rather than using its original world-space transform.

As Instance
:   When enabled, the geometry is added as an instance instead of being merged into the main geometry.
    Some operations require realized (non-instance) geometry, so use this option accordingly.

Replace Original
:   - When enabled, the incoming geometry is replaced by the selected input geometry.
    - When disabled, the input geometry is added alongside the existing one.
user: How do I use Shortest Path in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Select a face or vertex path with `Ctrl`-`LMB`.

Selects all geometry along the shortest path from
the active vertex, edge, or face to the one which was selected.

Edge Tag (in Edge select mode only)
:   This select button indicates what should be done when selecting a vertex path with `Ctrl`-`LMB`:

    Select
    :   Just selects all the edges in the path.

    Tag Seam
    :   Marks all edges in the path as seams for UV unwrapping.

    Tag Sharp
    :   Marks all edges in the path as sharp for the Edge Split Modifier.

    Tag Crease
    :   Marks all edges in the path as creases for the Subdivision Surface Modifier, with weight 1.0.

    Tag Bevel
    :   Gives bevel weight 1.0 (for the Bevel Modifier) to all edges in the path.

    Tag Freestyle Edge Mark
    :   Marks all edges in the path as Freestyle edges.

Face Stepping
:   Supports diagonal paths for vertices and faces, and
    selects edge rings with edges.

Topology Distance
:   Only takes into account the number of edges of the path and
    not the length of the edges to calculate the distances.

Fill Region `Shift`-`Ctrl`-`LMB`
:   Selects all elements in the shortest paths from the active selection to the clicked area.

Checker Deselect Options
:   Allows to quickly select alternate elements in a path.

    Deselected
    :   The number of deselected elements in the repetitive sequence.

    Selected
    :   The number of selected elements in the repetitive sequence.

    Offset
    :   Offset from the starting point.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`Bone.color`](bpy.types.Bone.html#bpy.types.Bone.color "bpy.types.Bone.color") - [`EditBone.color`](bpy.types.EditBone.html#bpy.types.EditBone.color "bpy.types.EditBone.color") | - [`PoseBone.color`](bpy.types.PoseBone.html#bpy.types.PoseBone.color "bpy.types.PoseBone.color") |
user: Provide the full official documentation entry for Stretch To Constraint, preserving all code examples.

assistant: # Stretch To Constraint

The *Stretch To* constraint makes an object or bone point at, and scale towards,
a target. Unlike the other “track” constraints, it can only do this using the local Y axis,
making it mainly useful for bones.

The constraint can also perform “volume preservation,” making the owner thinner when the
target moves away and thicker when it comes closer. This is useful for stretching
and squashing of stylized characters, for example. However, because it simply
adjusts the X and Z scales according to the Y scale, it works for any type of object,
not just meshes.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`Context.blend_data`](bpy.types.Context.html#bpy.types.Context.blend_data "bpy.types.Context.blend_data") | - [`RenderEngine.update`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.update "bpy.types.RenderEngine.update") |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Image
:   Image to put in place of the plane track, and thus, override that area in the movie clip.

### Motion Blur

Specify whether to use blur caused by motion of the plane track or not.

Samples
:   Set the number of samples to take for each frame.
    The higher this number, the smoother the blur effect,
    but the longer the render, as each virtual intermediate frame has to be rendered.

Shutter
:   Time (in frames) the shutter is open.
    If you are rendering at 24 fps, and the Shutter is set to 0.5,
    the time in between frames is 41.67 ms,
    so the shutter is open for half that, 20.83 ms.
user: Show practical ways to work with Annotations in a Blender add-on or script – include code.

assistant: Annotation tool strokes can be enabled/disabled with the checkbox in the panel header.
It is a standard annotations panel where annotation layers and frames can be controlled.
There is one difference in the behavior of the annotation tools from other areas –
when a new layer is created “on-demand” (when making a stroke without adding a layer before this)
the default color for the layer is set to pink. This heightens the color contrast to make
the stroke more noticeable on all kinds of movies.

Data Source
:   Determines the data-block type the current annotation layer is stored.

    Clip:
    :   Store the current annotation layer with the active *Movie Clip* data-block.

    Track:
    :   Store the current annotation layer with the active *Track* data-block.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Surface Geometry
:   The surface geometry to which the hair curves are attached.
    This is typically the same mesh used during hair generation or interpolation.

Surface UV Map
:   The UV map on the surface mesh used to locate the curve attachment points.
    It allows retrieving the stored attachment coordinates for each curve.
user: Show practical ways to work with Hue/Saturation Tips in a Blender add-on or script – include code.

assistant: Some things to keep in mind that might help you use this node better:

Hues are laid out on a circle
:   If you apply a Hue offset of 1 (+180°) to a blue image, you get the diametrically opposite
    color, which is yellow. If you apply a Hue offset of 1 to that yellow image, you get blue again.

Grayscale images have no hue
:   Trying to change the Hue or Saturation of a grayscale image has no effect. You can only brighten
    or darken it by adjusting the Value. To add color, use the Mix node instead.

Changing the effect over time
:   The different values can be animated using a *Time Curve* node or by setting keyframes.
user: Explain Clean Up in complete detail according to the official Blender documentation.

assistant: ### Clean Tracks

Identifies all tracks which matches settings from above and performs desired action on them.

Tracked Frames
:   Tracks or tracked segments shorter than this number of frames will be removed.

Reprojection Error
:   Tracks which has reprojection error higher than this value will be removed.

Action
:   Several actions can be performed for bad tracks.

    Select
    :   They can simply be selected.

    Delete Track
    :   The whole track can be deleted.

    Delete Segments
    :   Bad segments of tracked sequence can be removed.

### Filter Tracks

This operator deletes obviously bad tracks (for example, the ones which are too short).
Additionally, it identifies tracks which has suspicious spikes in their motion and selects them.
user: Give a detailed overview of WORKSPACE_UL_addons_items(UIList): syntax, arguments, return values, common patterns.

assistant: # WORKSPACE_UL_addons_items(UIList)

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

*class* bpy.types.WORKSPACE_UL_addons_items(*UIList*)
:   draw_item(*context*, *layout*, *_data*, *addon*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    filter_items(*_context*, *data*, *property*)

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

assistant: # Set Geometry Name Node

[image reference removed]

The *Set Geometry Name* node stores a custom name on the geometry, overriding the name which
might come from the [Object Info Node](../../input/scene/object_info.html) or a
[Grease Pencil to Curves Node](../../grease_pencil/operations/grease_pencil_to_curves.html).
The name is displayed in the spreadsheet and can helpful for debugging purposes.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`ActionChannelbags.new`](bpy.types.ActionChannelbags.html#bpy.types.ActionChannelbags.new "bpy.types.ActionChannelbags.new") - [`ActionChannelbags.remove`](bpy.types.ActionChannelbags.html#bpy.types.ActionChannelbags.remove "bpy.types.ActionChannelbags.remove") | - [`ActionKeyframeStrip.channelbag`](bpy.types.ActionKeyframeStrip.html#bpy.types.ActionKeyframeStrip.channelbag "bpy.types.ActionKeyframeStrip.channelbag") - [`ActionKeyframeStrip.channelbags`](bpy.types.ActionKeyframeStrip.html#bpy.types.ActionKeyframeStrip.channelbags "bpy.types.ActionKeyframeStrip.channelbags") |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Curves
:   Standard geometry input with a curve component.

Value
:   A field input to evaluate custom attributes.
    The evaluation is outputted through the *Value* output.

Factor Factor mode
:   The portion of the total length used to determine the sample position.

Length Length mode
:   A length in distance units used to determine how far along the curve to travel before sampling.

Curve Index
:   An index to only evaluate specific splines, these indices can be specified manually
    or from the [Index Node](../../geometry/read/input_index.xhtml).
    This input is ignored when the *All Curves* property is enabled.
user: Describe Parenting Objects from the Blender manual or Python API, including usage steps and snippets.

assistant: # Parenting Objects

When modeling a complex object, such as a watch, you may choose to model the different parts as separate objects.
To make all the parts move as one (“the watch”), you can designate one object as the *parent* of all the other parts.
These other parts become its *children*, and any translation, rotation, or scale of the parent will also
affects its children.

Contrary to most biological lifeforms, each object or bone in Blender has at most one parent.
If an object already has a parent object and you give it another parent then Blender will remove
the previous parent relationship. When the plural “parents” is used in this chapter,
it references the hierarchy of parents, so the parent, the grandparent, great grandparent,
and so on, of an object.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: By default, the position of vertices on the edge loop move as a percentage of the distance
between their original position and the adjacent edge loop, regardless of the edges’ lengths.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_edge-slide_before.png   Selected edge loop. | ../../../../_images/modeling_meshes_editing_edge_edge-slide_after.png   Repositioned edge loop. |

### Even Mode

*Even* mode keeps the shape of the selected edge loop the same as one of the edge loops adjacent to it,
rather than sliding a percentage along each perpendicular edge.

In *Even* mode, the tool shows the position along the length of the currently selected edge
which is marked in yellow, from the vertex that has an enlarged red marker.
Movement of the sliding edge loop is restricted to this length. As you move the mouse
the length indicator in the header changes showing where along the length of the edge you are.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_edge-slide_even.png   Even Mode enabled. | ../../../../_images/modeling_meshes_editing_edge_edge-slide_even-flip.png   Even Mode with Flip enabled. |

Moving the mouse moves the selected edge loop towards or away from the start vertex,
but the loop line will only move as far as the length of the currently selected edge,
conforming to the shape of one of the bounding edge loops.

### Limitations & Workarounds

There are restrictions on the type of edge selections that can be operated upon.
Invalid selections are:

Loop Crosses Itself
:   This means that the tool could not find any suitable faces that were adjacent to the selected edge(s).
    An example that shows this is selecting two edges that share the same face.
    A face cannot be adjacent to itself.

Multiple Edge Loops
:   The selected edges are not in the same edge loop, which means they do not have a common edge.
    You can minimize this error by always selecting edges end-to-end or in a “chain”.
    If you select multiple edges just make sure they are connected.
    This will decrease the possibility of getting looping errors.

Border Edges
:   When a single edge was selected in a single-sided object.
    An edge loop cannot be found because there is only one face.
    Remember, edge loops are loops that span two or more faces.

A general rule of thumb is that if multiple edges are selected they should be connected end-to-end
such that they form a continuous chain. This is *literally* a general rule because you
can still select edges in a chain that are invalid because some of the edges in the chain are
in different edge loops.
user: How do I use Transform Cache Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Transform Cache Constraint

The *Transform Cache Constraint* streams an animation from an
[Alembic](../../../files/import_export/alembic.xhtml) or [USD](../../../files/import_export/usd.xhtml)
file. For example, it can apply a baked rigid body simulation to an object.

The constraint is automatically added when importing such a file. However, it only applies
to transforms (location/rotation/scale of the whole object). For animations that cause
deformation, the [Mesh Sequence Cache Modifier](../../../modeling/modifiers/modify/mesh_sequence_cache.xhtml) is used instead.
user: How do I use Smooth in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Smooth (Gaussian)

Smooths the selected keyframes using a Gaussian kernel. Click the menu item, move the mouse left or right to
adjust the strength, and click `LMB` to confirm (or `RMB` to cancel).

Factor
:   How strongly the smoothing should be applied.

Sigma
:   The shape of the Gaussian distribution. Lower values mean a sharper curve, giving keys that are close to each
    other more weight. A high value behaves like a simple average filter.

Filter Width
:   A wider filter looks at more keyframes, producing a smoother result.
    At a width of 1, the filter only looks at the keyframes to the immediate left and right for a weighted average.

[image reference removed]

F-Curve after applying the Gaussian Smooth with the original curve overlaid.

### Smooth (Legacy)

There is also an option to smooth the selected curves, but beware: its algorithm seems to be
to halve the distance between each keyframe and the average linear value of the curve,
which gives quite a strong smoothing! Note that the first and last keys
seem to be never modified by this tool.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_clean1.png   F-Curve before smoothing. | ../../../_images/editors_graph-editor_fcurves_editing_smooth.png   F-Curve after smoothing. |

### Butterworth Smooth

Smooth the selected keyframes using a Butterworth filter. Click the menu item,
move the mouse left or right to adjust the frequency,
and click `LMB` to confirm (or `RMB` to cancel).

This filter is ideal for smoothing large amounts of data because it preserves the peaks
of the animation. The downside is that it can introduce a ripple effect when the key
values change rapidly.

Frequency Cutoff
:   The lower the value, the smoother the curve. There is an implicit maximum at which
    the value no longer changes the curve, which is at half the sample rate. The sample
    rate in this case is the scene frame rate multiplied by the **Samples per Frame** of this operator.

Filter order
:   Higher values mean the frequency cutoff is steeper.

Samples per Frame
:   Before the filter is applied, the curve is resampled at this interval to avoid errors when there
    are uneven spaces between frames. If keys are on subframes, e.g. a 60fps file in a 30fps scene,
    increase this value to 2.

Blend
:   A value between 0 and 1 for blending between the original curve and the smoothed one.

Blend In/Out
:   The number of frames at the start and end for which to blend between the original and smoothed curve.
    This can help reduce jumps in the animation at the selection border. At value 1, it only locks the first and
    last frames of the selection to their original values.
user: Give a detailed overview of Node Timings Overlay: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The node timings overlay.

Node timings show how long a node took to execute the last time the node group was evaluated.
They can be turned on in the overlays popover on the top right of the node editor.
When a node group is used in multiple places, the timings depend on the context of
the node editor, which is displayed in the path on the top left.

Frame nodes display the total time from all of the contained nodes
and the *Group Output* node displays the total time for the entire node group.

The displayed timings should only be considered an approximation, since they can
also take into account actions like copying or deleting a geometry input that aren’t
part of the node’s operation. Also, when a node uses multiple CPU cores, the evaluation
system might work on other nodes at the same time. It’s also important to remember
that [field nodes](fields.xhtml#field-node-types) generally don’t do work by themselves,
so their execution time is only added to the data-flow nodes they are connected to.
user: Explain Language in complete detail according to the official Blender documentation.

assistant: Language
:   The language used for translating the user interface (UI).
    The list is broken up into categories determining how complete the translations are.

Translate
:   Tooltips
    :   Translates the descriptions when hovering over UI elements.

    Interface
    :   Translates all labels in menus, buttons, and panels.

    New Data
    :   Translates the names of new data-blocks.
user: Explain Bpy.Types.Spaceproperties in complete detail according to the official Blender documentation.

assistant: ype ( str ) – Region type the callback was added to. Inherited Properties ¶ bpy_struct.id_data Space.type Space.show_locked_time Space.show_region_header Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values Space.bl_rna_get_subclass Space.bl_rna_get_subclass_py Space.draw_handler_add Space.draw_handler_remove Next SpaceSequenceEditor(Space) Previous SpacePreferences(Space) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page SpaceProperties(Space) SpaceProperties SpaceProperties.context SpaceProperties.outliner_sync SpaceProperties.pin_id SpaceProperties.search_filter SpaceProperties.show_properties_bone SpaceProperties.show_properties_bone_constraints SpaceProperties.show_properties_collection SpaceProperties.show_properties_constraints SpaceProperties.show_properties_data SpaceProperties.show_properties_effects SpaceProperties.show_properties_material SpaceProperties.show_properties_modifiers SpaceProperties.show_properties_object SpaceProperties.show_properties_output SpaceProperties.show_properties_particles SpaceProperties.show_properties_physics SpaceProperties.show_properties_render SpaceProperties.show_properties_scene SpaceProperties.show_properties_strip SpaceProperties.show_properties_strip_modifier SpaceProperties.show_properties_texture SpaceProperties.show_properties_tool SpaceProperties.show_properties_view_layer SpaceProperties.show_properties_world SpaceProperties.tab_search_results SpaceProperties.use_pin_id SpaceProperties.bl_rna_get_subclass() SpaceProperties.bl_rna_get_subclass_py() SpaceProperties.draw_handler_add() SpaceProperties.draw_handler_remove() Inherited Properties Inherited Functions
user: Provide the full official documentation entry for Scripting & Security, preserving all code examples.

assistant: # Scripting & Security

The ability to include Python scripts within blend-files is valuable for advanced tasks
such as rigging and automation. However, it poses a security risk since
Python does not restrict what a script can do.
Therefore, you should only run scripts from sources you know and trust.
Automatic execution is disabled by default;
however, some blend-files need this to function properly.

When a blend-file tries to execute a script and is not allowed, a dialog will appear.
In it, you can choose to *Allow Execution* or to *Ignore* the scripts.

[image reference removed]

An Auto-run warning in the Info editor’s header.
user: Describe GeometryNodeBake(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeBake(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.GeometryNodeBake(*GeometryNode*)
:   Cache the incoming data so that it can be used without recomputation

    active_index
    :   Index of the active item

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

    active_item
    :   Index of the active item

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: These settings control how the soft body will react (deform)
once it either gets close to or actually intersects (cuts into) another collision object on the same layer.

Choke
:   Calms down (reduces the exit velocity of) a vertex or edge once it penetrates a collision mesh.

Fuzzy
:   Fuzziness while on collision, high values make collision handling faster but less stable.
    Simulation is faster, but less accurate.
user: Show practical ways to work with Wave Modifier in a Blender add-on or script – include code.

assistant: # Wave Modifier

The *Wave* modifier adds a ripple-like motion to an object’s geometry.

This modifier is available for meshes, lattices, curves, surfaces and texts.

|  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_modifiers_deform_wave_example-circular.jpg   Circular wave front. | ../../../_images/modeling_modifiers_deform_wave_example-linear.jpg   Linear wave front. | ../../../_images/modeling_modifiers_deform_wave_example-normals.jpg   Motion enabled for X, Normals enabled for Y. |
user: Show practical ways to work with GeometryNodeGridCurl(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeGridCurl(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.GeometryNodeGridCurl(*GeometryNode*)
:   Calculate the magnitude and direction of circulation of a directional vector grid

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

assistant: |  |  |
| --- | --- |
| - [**Action**](glossary/index.xhtml#term-Action) - [**Action Safe**](glossary/index.xhtml#term-Action-Safe) - [**Active**](glossary/index.xhtml#term-Active) - [Add-ons](addons/index.xhtml#index-0), [[1]](advanced/extensions/addons.xhtml#index-1) - [Add-ons Extensions](advanced/extensions/addons.xhtml#index-0) - [**Aliasing**](glossary/index.xhtml#term-Aliasing) - [**Alpha Channel**](glossary/index.xhtml#term-Alpha-Channel) - [**Ambient Light**](glossary/index.xhtml#term-Ambient-Light) - [**Ambient Occlusion**](glossary/index.xhtml#term-Ambient-Occlusion) | - [**Animation**](glossary/index.xhtml#term-Animation) - [**Anti-Aliasing**](glossary/index.xhtml#term-Anti-Aliasing) - [**Armature**](glossary/index.xhtml#term-Armature) - [**Asset**](glossary/index.xhtml#term-Asset) - [**Asset Catalog**](glossary/index.xhtml#term-Asset-Catalog) - [**Asset Library**](glossary/index.xhtml#term-Asset-Library) - [**Asset Metadata**](glossary/index.xhtml#term-Asset-Metadata) - [**Attribute**](glossary/index.xhtml#term-Attribute) - [**Axis**](glossary/index.xhtml#term-Axis) - [**Axis Angle**](glossary/index.xhtml#term-Axis-Angle) |
user: How do I use Bounding Box Center in Blender? Include parameters, examples, warnings and best practices.

assistant: # Bounding Box Center

In this mode, the pivot point lies at the center of the bounding box, which is a box that’s
wrapped as tightly as possible around the selection while still being aligned to the world axes.
user: Explain Texture Preview in complete detail according to the official Blender documentation.

assistant: If your texture is already used to color, bump map, displace, alpha-transparent, etc.,
a surface of a model in your scene (in other technical words,
is mapped to some aspect of a texture via a texture channel using UV as a map input),
you can see the effects of your painting in the context of your scene as you paint.

To do this, set up side-by-side areas, one Area in 3D Viewport set to *Texture* shading option,
and in the second Area the Image Editor loaded with your image.
Position the 3D Viewport to show the object that is UV-mapped to the loaded image.
In the image to the right, the texture being painted is mapped to the “Normal” attribute,
and is called “bump mapping”, where the grayscale image is used to make the flat surface appear bumpy.
See Texture Mapping Output for more information on bump mapping.
user: Give a detailed overview of Video: syntax, arguments, return values, common patterns.

assistant: Strobe
:   Display every nth frame.
    For example, if you set this to 10, the strip will only display frames 1, 11, 21, 31, 41… of the source.

    It is important to realize that this property is a float value.
    This allows you to strobe effect synced exactly to a beat.

Reverse Frames
:   Plays the strip backwards starting from the last frame in the sequence.
user: Provide the full official documentation entry for GeometryNodeGreasePencilToCurves(GeometryNode), preserving all code examples.

assistant: # GeometryNodeGreasePencilToCurves(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.GeometryNodeGreasePencilToCurves(*GeometryNode*)
:   Convert Grease Pencil layers into curve instances

    *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 NodeTreeInterfaceSocketVectorAcceleration(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketVectorAcceleration(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.NodeTreeInterfaceSocketVectorAcceleration(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

        Type:
        :   float in [-inf, inf], default 0.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 Inputs, preserving all code examples.

assistant: Vertex Index
:   The index of the vertex for which to find the corners.

Weights
:   The weights of the corners in the geometry. Unlike the other inputs which follow
    the context domain, this one is always evaluated in the Face Corner domain.

    The corners are sorted by their associated weight in ascending order.
    Corners with the same weight are sorted by their index.

Sort Index
:   The 0-based index of the corner to select from the vertex’s sorted corners.
    If this value is outside the range of valid indices, it wraps around.