PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with CompositorNodeViewer(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeViewer(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.CompositorNodeViewer(*CompositorNode*)
:   Visualize data from inside a node graph, in the image editor or as a backdrop

    ui_shortcut
    :   Type:
        :   int in [-32768, 32767], default 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: Explain Start Editing Stashed Action in complete detail according to the official Blender documentation.

assistant: Enters Tweak Mode for the selected strip’s action, making its keyframes available for editing in
e.g. the [Graph Editor](../../graph_editor/introduction.xhtml). In addition, marks the strip’s
track as *Solo*, muting all the other tracks – this way, they no longer influence the animation
and you can focus exclusively on the action you’re editing.

While the menu item refers to stashed (muted) actions, this only reflects the typical use case.
It works on unmuted actions as well.

When you’re done editing, click Strip ‣ Stop Editing Stashed Action
or press `Shift`-`Tab` again.

|  |  |
| --- | --- |
| ../../../_images/editors_nla_editing_nla-mode.png   Strip in NLA mode. | ../../../_images/editors_nla_editing_edit-mode.png   Strip in Tweak mode. |
user: How do I use Video Editing App Template in Blender? Include parameters, examples, warnings and best practices.

assistant: # Video Editing App Template

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

[image reference removed]

The default Video Editing app template.
user: Explain DriverVariable(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # DriverVariable(bpy_struct)

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

*class* bpy.types.DriverVariable(*bpy_struct*)
:   Variable from some source/target for driver relationship

    is_name_valid
    :   Is this a valid name for a driver variable

        Type:
        :   boolean, default False, (readonly)

    name
    :   Name to use in scripted expressions/functions (no spaces or dots are allowed, and must start with a letter)

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

    targets
    :   Sources of input data for evaluating this variable

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

    type
    :   Driver variable type

        - `SINGLE_PROP`
          Single Property – Use the value from some RNA property.
        - `TRANSFORMS`
          Transform Channel – Final transformation value of object or bone.
        - `ROTATION_DIFF`
          Rotational Difference – Use the angle between two bones.
        - `LOC_DIFF`
          Distance – Distance between two bones or objects.
        - `CONTEXT_PROP`
          Context Property – Use the value from some RNA property within the current evaluation context.

        Type:
        :   enum in [`'SINGLE_PROP'`, `'TRANSFORMS'`, `'ROTATION_DIFF'`, `'LOC_DIFF'`, `'CONTEXT_PROP'`], default `'SINGLE_PROP'`

    *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](#bpy.types.DriverVariable.type "bpy.types.DriverVariable.type")
user: Give a detailed overview of Modifiers: syntax, arguments, return values, common patterns.

assistant: ### Common Options

Mix
:   The modifier output can be mixed with the base property using the usual methods
    (see for example the [Mix compositing node](../../../../compositing/types/color/mix_color.xhtml)).

Influence
:   How much the result of this modifier affects the current property.

### Types

- [Along Stroke](modifiers/thickness/along_stroke.xhtml)
- [Calligraphy](modifiers/thickness/calligraphy.xhtml)
- [Crease Angle](modifiers/thickness/crease_angle.xhtml)
- [Curvature 3D](modifiers/thickness/curvature_3d.xhtml)
- [Distance from Camera](modifiers/thickness/distance_from_camera.xhtml)
- [Distance from Object](modifiers/thickness/distance_from_object.xhtml)
- [Material](modifiers/thickness/material.xhtml)
- [Noise](modifiers/thickness/noise.xhtml)
- [Tangent](modifiers/thickness/tangent.xhtml)
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Normal Edit Modifier.

Radial
:   Aligns normals with the `(origin, vertex_coordinates)` vector, in other words all normals seems to radiate
    from the given center point, as if they were emitted from an ellipsoid surface.

Directional
:   Makes all normals point (converge) towards a given target object.

Target
:   Uses this object’s origin as reference point when generating normals.

    Optional in *Radial* mode, mandatory in *Directional* one.

Parallel Normals
:   Makes all normals parallel to the line between both objects’ origins,
    instead of converging towards target’s origin.

    Only relevant in *Directional* mode.

### Mix

Mix Mode
:   How to affect existing normals with newly generated ones.

    Note that the *Multiply* option is **not** a cross product, but a faster component-by-component multiplication.

Mix Factor
:   How much of the generated normals get mixed into existing ones.

Vertex Group
:   Allows per-item fine control of the mix factor. The vertex group influence can be inverted by using
    the arrow button to the right.

Max Angle
:   Forbids new generated normals to have an angle to the original normal above that given threshold.
    This is useful to prevent extreme changes, that can even lead to inverting the front/back sides of a face,
    and consequently to shading artifacts.

    / Lock Polygon Normals
    :   Prevents flipping (reversing front/back sides) of polygons which normal does not match anymore
        the side to which point its corners’ custom normals. Can also help to avoid shading issues.

### Offset

Gives modified object’s origin an offset before using it to generate normals.

Only relevant in *Radial* mode if no *Target Object* is set,
and in *Directional* mode when *Parallel Normals* is set.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: A
:   The background image.

Depth A
:   Depth pass of the background image.

B
:   The foreground image.

Depth B
:   Depth pass of the foreground image.

Use Alpha
:   The chosen Image pixel alpha channel is also carried over.
    If a pixel is partially or totally transparent,
    the result of the Depth Combine will also be partially transparent;
    in which case the background image will show through the foreground (chosen) pixel.

Anti-Alias
:   Applies [Anti-Aliasing](../../../glossary/index.xhtml#term-Anti-Aliasing) to avoid artifacts at sharp edges or areas with a high contrast.
user: Give a detailed overview of Asset Shelf Region: syntax, arguments, return values, common patterns.

assistant: Depending on the current mode, the asset shelf may be available, providing quick access to assets
for this specific mode (for example brush assets in *Paint* mode).

See [Asset Shelf](../../interface/window_system/regions.html#ui-region-asset-shelf) for more information.
user: Show practical ways to work with Collection Exporters in a Blender add-on or script – include code.

assistant: This exporter can be used as a collection exporter.
See [Collections](../../scene_layout/collections/collections.xhtml) for more information about collections and their exporters.

Here are the options & specificity for collection export:

- Include part of options are not available for collection exporter (like every other exporter).
- Option to export at collection center (at center of mass of all root objects of the collection).
- Custom Properties of the collection are exported as Scene glTF extras.
user: Show practical ways to work with Get Involved in a Blender add-on or script – include code.

assistant: Help write Blender’s future! ✏️ Contribute to the Blender Manual and share your knowledge with creators worldwide.
No matter your expertise, your contributions can make Blender easier to learn and use for everyone.
Join the team and [start documenting Blender](contribute/manual/index.html#about-user-contribute) today!

Translations

Help bring Blender to the world! 🌍
Join the translation effort to make the Blender accessible in more languages.

- [Translate Blender’s UI](contribute/translate_blender.html)
- [Translate Blender’s User Manual](contribute/translate_manual/index.html)
user: What is Options and how is it used in Blender Python scripting?

assistant: As the modifier is only a container its actual options are configured in the *Physics Properties* tab.
See the [Soft Body Physics Properties](../../../physics/soft_body/settings/index.xhtml) for more information.
user: Explain Swapping Contents in complete detail according to the official Blender documentation.

assistant: You can swap the contents of two areas by pressing `Ctrl`-`LMB`
on one of the corners of the initial area, dragging towards the target area,
and releasing the mouse there. The two areas do not need to be side-by-side,
though they must be inside the same window.
user: Describe Preview Snapping from the Blender manual or Python API, including usage steps and snippets.

assistant: # Preview Snapping

The icon toggles snapping;
you can also do this temporarily by holding `Ctrl` after starting to transform an image.

Images have multiple snap points; they can snap along their edges, corners, or center.

The drop-down arrow offers the following options:

Snap to
:   Borders
    :   Snap images to the edges of the render region.

    Center
    :   Snap images to the horizontal and vertical center lines of the render region.

    Other Strips
    :   Snap images to the snap points of other images.
user: Provide the full official documentation entry for Property Subtype Number Items, preserving all code examples.

assistant: # Property Subtype Number Items

PIXEL:
:   Pixel.

    A distance on screen.

PIXEL_DIAMETER:
:   Pixel.

    A distance on screen, specifically representing a diameter value.

UNSIGNED:
:   Unsigned.

PERCENTAGE:
:   Percentage.

    A percentage between 0 and 100.

FACTOR:
:   Factor.

    A factor between 0.0 and 1.0.

ANGLE:
:   Angle.

    A rotational value specified in radians.

TIME:
:   Time (Scene Relative).

    Time specified in frames, converted to seconds based on scene frame rate.

TIME_ABSOLUTE:
:   Time (Absolute).

    Time specified in seconds, independent of the scene.

DISTANCE:
:   Distance.

    A distance between two points.

DISTANCE_DIAMETER:
:   Distance.

    A distance between two points, specifically representing a diameter value.

DISTANCE_CAMERA:
:   Camera Distance.

POWER:
:   Power.

TEMPERATURE:
:   Temperature.

WAVELENGTH:
:   Wavelength.

COLOR_TEMPERATURE:
:   Color Temperature.

FREQUENCY:
:   Frequency.

NONE:
:   None.
user: How do I use Rest Pose in Blender? Include parameters, examples, warnings and best practices.

assistant: The initial shape of a B-Bone can be defined in Edit Mode as a rest pose of that bone.
This is useful for curved facial features like curved eyebrows or mouths.

B-Bones have two sets of the Bendy Bone properties – one for Edit Mode (i.e. the Rest Pose/Base Rig) and
another for Pose Mode – adding or multiplying together their values to get the final transforms.
user: Give a detailed overview of Socket Syncing: syntax, arguments, return values, common patterns.

assistant: Closures rely on matching socket names to connect inputs and outputs correctly.
If the connected *Closure Zone* and *Evaluate Closure* nodes have mismatched signatures, Blender can synchronize them
automatically.

- A sync icon appears when the socket layout differs.
- Clicking the icon updates sockets to match the connected closure.
- Automatic syncing occurs the first time a closure is connected.
- Existing sockets are never modified automatically afterward to prevent data loss.
user: Describe Header from the Blender manual or Python API, including usage steps and snippets.

assistant: Only Show Selected
:   Displays the graph for only selected trackers.

Display Hidden
:   Displays channels from objects that are hidden.

Show Frames
:   Visualizes per-frame average reprojection error of all tracks in the active tracking object.

Show Tracks Motion
:   Shows curves for X and Y speed of tracks.

Show Tracks Error
:   Per-frame reprojection error of tracks.
user: Give a detailed overview of Set Handle Positions Node: syntax, arguments, return values, common patterns.

assistant: # Set Handle Positions Node

[image reference removed]

The *Set Handle Positions* node sets the positions for the handles of [Bézier curves](../../../curves/structure.xhtml#curve-bezier).
They can be used to alter the generated shape of the curve.
The input node for this data is the [Curve Handle Positions Node](../read/curve_handle_positions.xhtml).
See the [Bézier curves](../../../curves/structure.xhtml#curve-bezier-handle-type) page for more details.
user: Explain Editing in complete detail according to the official Blender documentation.

assistant: Flip (Distortion Free)
:   Mirrors the vertices displacement from their base position.

    U, V, W

Make Regular
:   Resets the whole lattice to a regular grid, where the cells are scaled to one cubic unit.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: The node can contain an arbitrary number of input sockets.
Each socket can be given a custom name and type. Supported types include (but not limited to):

- Geometry
- Objects
- Values (e.g. float, integer, boolean, vector, color)
- Fields
- Nested Bundles
user: Explain Overhang in complete detail according to the official Blender documentation.

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

Minimum/Maximum
:   Minimum/Maximum angle to display.

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

[image reference removed]

Overhang.
user: Show practical ways to work with wmTools(bpy_struct) in a Blender add-on or script – include code.

assistant: # wmTools(bpy_struct)

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

*class* bpy.types.wmTools(*bpy_struct*)
:   from_space_view3d_mode(*mode*, *\**, *create=False*)
    :   Parameters:
        :   **create** (*boolean**,* *(**optional**)*) – Create

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

    from_space_image_mode(*mode*, *\**, *create=False*)
    :   Parameters:
        :   **create** (*boolean**,* *(**optional**)*) – Create

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

    from_space_node(*\**, *create=False*)
    :   Parameters:
        :   **create** (*boolean**,* *(**optional**)*) – Create

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

    from_space_sequencer(*mode*, *\**, *create=False*)
    :   Parameters:
        :   **create** (*boolean**,* *(**optional**)*) – Create

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

    *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 Poke Faces, preserving all code examples.

assistant: # Poke Faces

Splits each selected faces into a triangle fan,
creating a new center vertex and triangles between the original face edges
and new center vertex. The *Offset* can be used to make spikes or depressions.

Poke Offset
:   Offset the new center vertex along the face normal.

Offset Relative
:   Multiply the Offset by the average length from the center to the face vertices.

Poke Center
:   Computes the center of a face.

    Weighted Median:
    :   Using the mean average weighted by edge length.

    Median:
    :   Using the mean average.

    Bounds:
    :   Uses center of bounding box.
user: Provide the full official documentation entry for Cloth, preserving all code examples.

assistant: # Cloth

This brush simulates cloth physics on the mesh under the brush cursor.
There are various deformation types and settings to customize the brush.

It’s also easy to sculpt the mesh with other brushes and tools
in between using the cloth brushes.
user: Show practical ways to work with Volume in a Blender add-on or script – include code.

assistant: Sampling Method
:   Distance:
    :   For dense volumes lit from far away *Distance* sampling is usually more efficient.

    Equiangular:
    :   If you have got a light inside or near the volume then *equiangular* sampling is better.

    Multiple Importance:
    :   If you have a combination of both, then the multiple importance sampling will be better.

Interpolation
:   Interpolation method to use for the volume objects and smoke simulation grids.

    Linear:
    :   Simple interpolation which gives good results for thin volumes.

    Cubic:
    :   Smoothed high-quality interpolation needed for more dense volumes, but slower.

Step Rate Biased
:   Adjust distance between volume shader samples for volume shaders.
    This is typically used to reduce the step size for procedural shaders that add more detail
    with procedural textures, when it is not captured by the default step size.
    Only enabled when Render ‣ Volumes ‣ Biased is enabled.
    See [Volume Render Settings](render_settings/volumes.xhtml) for more information.
user: Show practical ways to work with Subsurface Scattering in a Blender add-on or script – include code.

assistant: # Subsurface Scattering

[image reference removed]

The *Subsurface Scattering* node is used to add simple subsurface multiple scattering,
for materials such as skin, wax, marble, milk and others. For these materials,
rather than light being reflect directly off the surface, it will penetrate the surface and
bounce around internally before getting absorbed or leaving the surface at a nearby point.

How far the color scatters on average can be configured per RGB color channel. For example,
for skin, red colors scatter further, which gives distinctive red-colored shadows,
and a soft appearance.
user: What is PathCompareCollection(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PathCompareCollection(bpy_struct)

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

*class* bpy.types.PathCompareCollection(*bpy_struct*)
:   Collection of paths

    *classmethod* new()
    :   Add a new path

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

    *classmethod* remove(*pathcmp*)
    :   Remove path

    *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: Closure
:   The closure to evaluate.
    This input expects a connection from a [Closure Zone](../../../../interface/controls/nodes/types/utilities/closure/closure.html).
    If no closure is connected, the node operates in *pass-through mode* (see below).

### Interface

The node can define additional inputs manually, which are matched by name to the corresponding inputs of the connected
closure. When the closure is connected, these sockets automatically sync to reflect the closure’s defined interface.
user: What is Themes and how is it used in Blender Python scripting?

assistant: # Themes

The *Themes* section allows you to customize interface appearance and colors.

[image reference removed]

The colors for each editor can be set separately by simply selecting the editor you wish to
change in the multi-choice list at the left, and adjusting colors as required.
Notice that changes appear in real-time on your screen. In addition, details such as the dot size
in the *3D Viewport* or the *Graph Editor* can also be changed.
user: Describe Contacts from the Blender manual or Python API, including usage steps and snippets.

assistant: [Project Page](https://projects.blender.org/blender/documentation)
:   An overview of the documentation project.

[Documentation Forum](https://devtalk.blender.org/c/documentation/12)
:   A forum based discussions on writing and translating documentation. This includes the user manual, Wiki, release
    notes, and code docs.

[Chat](../../getting_started/about/community.xhtml#blender-chat)
:   `#docs` channel for informal discussions in real-time.

[Project Workboard](https://projects.blender.org/blender/documentation/projects)
:   Manage tasks such as bugs, todo lists, and future plans.
user: Give a detailed overview of NodeFunctionFormatStringItem(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NodeFunctionFormatStringItem(bpy_struct)

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

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

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

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

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

    *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 Mesh Cache Modifier, preserving all code examples.

assistant: # Mesh Cache Modifier

The *Mesh Cache* modifier applies animated mesh data from an external file to a mesh, allowing it to deform over time.
It is commonly used for importing animations from other applications, enabling smooth playback of cached deformations.

This modifier functions similarly to [shape keys](../../../animation/shape_keys/introduction.html),
but is specifically designed for playback of externally stored animations rather than keyframe-based deformations.
user: Give a detailed overview of Transform: syntax, arguments, return values, common patterns.

assistant: # Transform

[image reference removed]

Transform Properties.

The *Transform* panel in the Sidebar region allows you to view and
manually/numerically control the position, rotation, and other properties of an object, in *Object Mode*.
Each object stores its position, orientation, and scale values.
These may need to be manipulated numerically, reset, or applied.
In *Edit Mode*. It mainly allows you to enter precise coordinates for a vertex,
or median position for a group of vertices (including an edge/face). As each type of object has a different set of
options in its *Transform* panel in *Edit Mode*,
see their respective descriptions in the [Modeling chapter](../../../modeling/index.html).

Use this panel to either edit or display the object’s transform properties such as position,
rotation and/or scaling. These fields change the object’s origin and then affect the aspect of
all its *vertices* and faces.

Location
:   The object’s origin location in local coordinates.

Rotation
:   The object’s local orientation, relative to the global axes and its own origin.

Rotation Mode
:   Method for calculating rotations, additional information can be found
    in the [manual’s appendix](../../../advanced/appendices/rotations.html).

    Euler:
    :   The gizmo handles are aligned to the [Euler](../../../glossary/index.html#term-Euler) axis,
        allowing you to see the discreet XYZ axis underlying the Euler rotation,
        as well as possible [Gimbal Lock](../../../glossary/index.html#term-Gimbal-Lock).

    Axis Angle:
    :   The X, Y, and Z coordinates define a point relative to the object origin.
        This point and the origin define an axis around the W value defines the rotation.

    Quaternion:
    :   X, Y, Z and W correspond to the [Quaternion](../../../glossary/index.html#term-Quaternion) components.

Scale
:   The object’s relative scale along the local axis
    (e.g. the *Scale X* value represents the scale along the local X axis).
    Each object (cube, sphere, etc.), when created, has a scale of one unit in each local direction.
    To make the object bigger or smaller, you scale it in the desired axis.

Dimensions
:   The size of the object’s bounding box
    (aligned with the local axes – think of a cardboard box just big enough to hold the object).

Transform Properties Locking
:   When the toggle is locked, the corresponding transformation value
    can not be changed in any interactive operation.
    But the value can still be changed using non-interactive operations,
    like editing the corresponding number field or using Python.

    For example, if you locked the *Location X* property
    then you cannot use the 3D gizmo to move the object along the global X axis.
    But you can still move it using the *Location X* number field.
    Consider the locking feature as a rigid constraint only changeable from the panel.

    To lock a property, click the padlock icon next to the button.
    The button is unlocked if the icon shows an open padlock,
    and it is locked if the icon appears as a closed padlock.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

The Video Sequencer allows you to place images, videos, sounds, and scenes
on a timeline and combine them into a new video. This section only describes its UI;
to read more about its usage, see the [Video Editing](../../video_editing/index.html) section.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`SpaceConsole.history`](bpy.types.SpaceConsole.html#bpy.types.SpaceConsole.history "bpy.types.SpaceConsole.history") | - [`SpaceConsole.scrollback`](bpy.types.SpaceConsole.html#bpy.types.SpaceConsole.scrollback "bpy.types.SpaceConsole.scrollback") |
user: Show practical ways to work with Workflow in a Blender add-on or script – include code.

assistant: # Workflow

Shape keys are created and managed in the [Shape Keys panel](shape_keys_panel.html),
found in the *Object Data* tab of the Properties editor
(for example, the *Mesh* tab for mesh objects).

A shape key is edited by selecting it in the panel and then moving the object’s vertices
to new positions in the 3D Viewport.

The panel also contains controls to adjust the *Value* (influence or weight) of each shape key.
This allows you to view a shape in isolation, or see how it combines with other active shape keys.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Speed Control
:   The method used to adjust the speed of the strip.

    Stretch:
    :   Automatically calculates the speed effect based on the length of the input strip.
        If you scale a strip to 1/2 the original size the sequence will play back at 2 times the speed.

    Multiply:
    :   Multiplies the current speed of the sequence by a *Multiply Factor*.
        Thus a value of 0.5 will make the sequence half as fast while 2 would make the sequence twice as fast.
        Negative values will reverse the input while also adjusting the speed,
        so a value of negative two will play in reverse and twice as fast as normal.

    Frame Number:
    :   Specifies a frame to remap the current frame to,
        for example, setting the *Frame Number* value to 50 displays the 50th frame.
        This can then be manually [keyframed](../../../../../animation/keyframes/index.xhtml) to recreate the animation.

    Length:
    :   Maps the frame range on a percentage scale. For example, using this and a value of 50%
        will select the frame halfway through the sequence.

Interpolation
:   Crossfades between frames to reduce screen tearing when the speed is slower than the original frame rate.
user: How do I use Torus in Blender? Include parameters, examples, warnings and best practices.

assistant: A doughnut-shaped primitive created by rotating a circle around an axis.
This shape is commonly used for rings, pipes, and stylized details.

Operator Presets
:   Saved torus settings that can be reused.
    These are stored as Python scripts in the presets directory.

Major Segments
:   Number of segments that make up the main circular ring of the torus.
    Think of this as the number of steps in the spin operation around the central axis.

Minor Segments
:   Number of segments making up the circular cross-section of the torus.
    Each segment is rotated around the main ring.

Dimensions Mode
:   Selects the method used to define the shape and size of the torus:

    Major/Minor:
    :   Define the torus using the radius of the main ring and the radius of the cross-sectional circle.

    Exterior/Interior:
    :   Define the torus using the total outer radius and the radius of the central hole.

Major Radius Major/Minor
:   Distance from the center of the torus to the center of the cross section.

Minor Radius Major/Minor
:   Radius of the cross-sectional circle (thickness of the ring).

Exterior Radius Exterior/Interior
:   Total radius from the center of the torus to its outer edge.

Interior Radius Exterior/Interior
:   Radius of the hole at the center of the torus.
user: Describe Visual Geometry as Mesh from the Blender manual or Python API, including usage steps and snippets.

assistant: Apply the visual state of all selected objects (modifiers, shape keys, hooks, etc.) to object data.
This is a way to freeze all object data into static meshes, as well as converts non-mesh types to mesh.

For details, see the [Convert](convert.html#object-convert-to) mesh.
user: How do I use Display Graphics in Blender? Include parameters, examples, warnings and best practices.

assistant: Settings that control how Blender draws its user interface and other display graphics.
These options can influence performance and compatibility.

Backend
:   Selects the graphics API used for drawing the interface and rendering display content.

    Changing the backend requires restarting Blender for the change to take effect.

    OpenGL:
    :   Uses the OpenGL backend.
        This is the traditional backend, compatible with a wide range of systems.

    Vulkan:
    :   Uses the Vulkan backend. Vulkan may offer improved performance and better support for modern GPU features,
        but compatibility may vary depending on the system and drivers.

Device Vulkan
:   Specifies which GPU device to use for display drawing operations.

    This setting is useful for systems with multiple GPUs (e.g., integrated + discrete)
    where you want to force Blender to use a specific GPU for UI rendering.

    Changing the backend requires restarting Blender for the change to take effect.

    Auto:
    :   Automatically selects the most appropriate GPU based on system configuration and driver support.
user: How do I use CompositorNodeChannelMatte(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeChannelMatte(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.CompositorNodeChannelMatte(*CompositorNode*)
:   Create matte based on differences in color channels

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

assistant: # bpy_extras submodule (bpy_extras.node_utils)

bpy_extras.node_utils.connect_sockets(*input*, *output*)
:   Connect sockets in a node tree.

    This is useful because the links created through the normal Python API are
    invalid when one of the sockets is a virtual socket (grayed out sockets in
    Group Input and Group Output nodes).

    It replaces node_tree.links.new(input, output)

bpy_extras.node_utils.find_base_socket_type(*socket*)
:   Find the base class of the socket.

    Sockets can have a subtype such as NodeSocketFloatFactor,
    but only the base type is allowed, e. g. NodeSocketFloat

bpy_extras.node_utils.find_node_input(*node*, *name*)
user: How do I use Mirror in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

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

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

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

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

After pasting with ‘Paste Mirrored’, the mirror axes can be chosen in the
[redo panel](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last).
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Shadow Visual Effect.

Shadow Color
:   Defines the shadow color.

Offset X, Y
:   Control the shadow displacement in pixels on the X and Y axis.

Scale X, Y
:   Control the size of the shadow on the X and Y axis.

Rotation
:   Sets the shadow rotation around the Grease Pencil object center
    or another object when *Use Object As Pivot* is enabled.

Object Pivot
:   When enabled, an *Object* is used by the shadow as the center of rotation.

### Blur

Blur X, Z
:   Control the blur scale in pixels on the X and Z axis.

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

### Wave Effect

When enabled, apply a wave distortion to the shadow.

Orientation
:   Sets horizontal or vertical direction for the waves.

Amplitude
:   Controls the strength and the depth of the wave.

Period
:   Controls the wave period. The time it takes to complete one cycle.

Phase
:   Shifts the wave pattern over the shadow.
user: What is LineStyleTextureSlot(TextureSlot) and how is it used in Blender Python scripting?

assistant: # LineStyleTextureSlot(TextureSlot)

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

*class* bpy.types.LineStyleTextureSlot(*TextureSlot*)
:   Texture slot for textures in a LineStyle data-block

    alpha_factor
    :   Amount texture affects alpha

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

    diffuse_color_factor
    :   Amount texture affects diffuse color

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

    mapping
    :   - `FLAT`
          Flat – Map X and Y coordinates directly.
        - `CUBE`
          Cube – Map using the normal vector.
        - `TUBE`
          Tube – Map with Z as central axis.
        - `SPHERE`
          Sphere – Map with Z as central axis.

        Type:
        :   enum in [`'FLAT'`, `'CUBE'`, `'TUBE'`, `'SPHERE'`], default `'FLAT'`

    mapping_x
    :   Type:
        :   enum in [`'NONE'`, `'X'`, `'Y'`, `'Z'`], default `'X'`

    mapping_y
    :   Type:
        :   enum in [`'NONE'`, `'X'`, `'Y'`, `'Z'`], default `'Y'`

    mapping_z
    :   Type:
        :   enum in [`'NONE'`, `'X'`, `'Y'`, `'Z'`], default `'Z'`

    texture_coords
    :   Texture coordinates used to map the texture onto the background

        - `WINDOW`
          Window – Use screen coordinates as texture coordinates.
        - `GLOBAL`
          Global – Use global coordinates for the texture coordinates.
        - `ALONG_STROKE`
          Along stroke – Use stroke length for texture coordinates.
        - `ORCO`
          Generated – Use the original undeformed coordinates of the object.

        Type:
        :   enum in [`'WINDOW'`, `'GLOBAL'`, `'ALONG_STROKE'`, `'ORCO'`], default `'ALONG_STROKE'`

    use_map_alpha
    :   The texture affects the alpha value

        Type:
        :   boolean, default False

    use_map_color_diffuse
    :   The texture affects basic color of the stroke

        Type:
        :   boolean, default True

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

assistant: - `LMB` Create a stroke material.
- `Shift`-`LMB` Create a fill material.
- `Shift`-`Ctrl`-`LMB` Create both a stroke and fill material.
- Holding `LMB` and dragging accumulates the average color under the mouse cursor.
user: Provide the full official documentation entry for Brush Settings, preserving all code examples.

assistant: # Brush Settings

Painting needs paint brushes and Blender provides a Brush panel within the Toolbar
when in *Weight Paint Mode*.

Brush
:   In the [Data-Block menu](../../../../interface/controls/templates/data_block.html#ui-data-block) you find predefined Brush presets.
    And you can create your own custom presets as needed.

Radius `F`
:   The radius defines the area of influence of the brush.

    (Size Pressure)
    :   Adjusts the radius based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.html#hardware-tablet).

Strength
:   This is the amount of paint to be applied per brush stroke.

    (Strength Pressure)
    :   Adjusts the strength based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.html#hardware-tablet).

Use Falloff
:   When enabled, use Strength falloff for the brush.
    Brush Strength decays with the distance from the center of the brush.

Weight `Ctrl`-`F`
:   The weight (visualized as a color) to be used by the brush.

    Using `Ctrl`-`RMB` you can set the weight to the value that’s under the cursor.

Direction `D`
:   Brush direction toggle, *Add* adds weight value while *Subtract* removes weight value.
    This setting can be toggled with `D`.
user: Provide the full official documentation entry for Inherited Properties, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`BoidRule.name`](bpy.types.BoidRule.html#bpy.types.BoidRule.name "bpy.types.BoidRule.name") - [`BoidRule.type`](bpy.types.BoidRule.html#bpy.types.BoidRule.type "bpy.types.BoidRule.type") | - [`BoidRule.use_in_air`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_in_air "bpy.types.BoidRule.use_in_air") - [`BoidRule.use_on_land`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_on_land "bpy.types.BoidRule.use_on_land") |
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Target Geometry
:   Geometry that rays are tested against.

Attribute
:   An optional field input evaluated on the *Target Geometry* that will be interpolated at the hit points.
    The resulting values are outputted with the *Attribute* output.

Interpolation
:   How attributes of the target mesh are mapped to the attribute values on the result geometry.

    Interpolated:
    :   Vertex and corner attributes are interpolated smoothly, with a bilinear function.

    Nearest:
    :   Choose the value of the closest vertex without interpolating.

Source Position
:   The position from where to start each ray. By default, this is the same as
    if the [Position Node](../read/position.xhtml) was connected.

Ray Direction
:   Direction of each ray from the starting position.
    The field is evaluated on the geometry from the context of the field evaluation, not the *Target Geometry*.

Ray Length
:   Maximum distance a ray can travel before being considered “no hit”.