PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is External and how is it used in Blender Python scripting?

assistant: Screen Grab Size
:   Size of the captured image for reprojecting.

Quick Edit
:   Edit a snapshot of the viewport in an external image editor.

Apply
:   Project edited image back onto the object.

Apply Camera Image
:   Project an edited render from the active camera back onto the object.
user: Provide the full official documentation entry for Simple, preserving all code examples.

assistant: Size
:   A multiplier for children size.

Random Size
:   Random variation to the size of child particles.

Radius
:   The radius in which the children are distributed around their parents.
    This is 3D, so children may be emitted higher or lower than their parents.

Roundness
:   The roundness of the children around their parents. Either in a sphere (1.0) or in-plane (0.0).
user: Show practical ways to work with Snap in a Blender add-on or script – include code.

assistant: Selection to Current Frame
:   Move the start of the selected strips to the current frame.

Selection to Nearest Frame
:   Move the start of the selected strips to the nearest full frame.

Selection to Nearest Second
:   Move the start of the selected strips to the nearest second.

Selection to Nearest Marker
:   Move the start of the selected strips to the nearest marker.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor. If there is no surface, this does the
        same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.xhtml)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.xhtml).

Snap To
:   The target to use while [Snapping](../controls/snapping.xhtml).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the side of the bounding box has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.

Segments
:   Number of vertical segments. Like the Earth’s meridians, going pole to pole.

Rings
:   Number of horizontal segments. These are like the Earth’s parallels.
user: Describe MovieTrackingDopesheet(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MovieTrackingDopesheet(bpy_struct)

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

*class* bpy.types.MovieTrackingDopesheet(*bpy_struct*)
:   Match-moving dopesheet data

    show_hidden
    :   Include channels from objects/bone that are not visible

        Type:
        :   boolean, default False

    show_only_selected
    :   Only include channels relating to selected objects and data

        Type:
        :   boolean, default False

    sort_method
    :   Method to be used to sort channels in dopesheet view

        - `NAME`
          Name – Sort channels by their names.
        - `LONGEST`
          Longest – Sort channels by longest tracked segment.
        - `TOTAL`
          Total – Sort channels by overall amount of tracked segments.
        - `AVERAGE_ERROR`
          Average Error – Sort channels by average reprojection error of tracks after solve.
        - `START`
          Start Frame – Sort channels by first frame number.
        - `END`
          End Frame – Sort channels by last frame number.

        Type:
        :   enum in [`'NAME'`, `'LONGEST'`, `'TOTAL'`, `'AVERAGE_ERROR'`, `'START'`, `'END'`], default `'NAME'`

    use_invert_sort
    :   Invert sort order of dopesheet channels

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Actions: syntax, arguments, return values, common patterns.

assistant: # Actions

*Actions* are Blender’s container for animation data. For example, when you
animate the location of an object, that animation is stored in an action rather
than directly on the object itself. The object then uses the action to get
animated, much the same way that a mesh uses a material to get shaded. All
animatable [data-blocks](../glossary/index.html#term-Data-Block)
([objects](../scene_layout/object/introduction.html),
[meshes](../modeling/meshes/introduction.html),
[materials](../render/materials/introduction.html), etc.) are animated this way:
they don’t store their own animation data, but instead use an action that stores
the animation data for them.

Actions are also data-blocks themselves, and therefore can be easily appended or
linked into other blend files. This lets actions be used not just for storage,
but also for organizing and reusing animation data. For example, if you’re
building a library of animations (run cycles, jumps, idling, etc.), each
animation can go into its own action, which can then be conveniently linked or
exported as a distinct animation.
user: Describe Fcurve Auto Smoothing Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Fcurve Auto Smoothing Items

NONE:
:   None.

    Automatic handles only take immediately adjacent keys into account.

CONT_ACCEL:
:   Continuous Acceleration.

    Automatic handles are adjusted to avoid jumps in acceleration, resulting in smoother curves. However, key changes may affect interpolation over a larger stretch of the curve..
user: Give a detailed overview of Known Limitations: syntax, arguments, return values, common patterns.

assistant: ### Duplicate Vertices

If a cut creates duplicate vertices, this is often caused by the clipping range
being too large. Try increasing the [Clip Start](../../../../editors/3dview/sidebar.xhtml#bpy-types-spaceview3d-clip-start)
to avoid this problem.
Also see [Depth Troubleshooting](../../../../troubleshooting/3d_view.xhtml#troubleshooting-depth) for details.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: Primitive
:   Ball
    :   Adds a meta with a point underlying structure.

    Capsule
    :   Adds a meta with a line segment underlying structure.

    Plane
    :   Adds a meta with a planar underlying structure.

    Ellipsoid
    :   Adds a meta with an ellipsoidal underlying structure.

    Cube
    :   Adds a meta with a volumetric cubic underlying structure.

Radius, Align to View, Location, Rotation
:   See [Common Object Options](../../scene_layout/object/types.html#object-common-options).
user: Show practical ways to work with Mesh to Curve Node in a Blender add-on or script – include code.

assistant: # Mesh to Curve Node

[image reference removed]

The *Mesh to Curve* node converts a mesh into one or more curve splines.

Two different conversion modes are supported, depending on the desired output:

- **Edges**: Turns each string of connected mesh edges into a poly spline.
  Whenever two or more edge strings intersect, they will be split into separate splines.
- **Faces**: Creates a cyclic spline from each mesh face. This mode is generally much faster than *Edges*,
  as it parallelizes easily and can share face and corner attributes without needing to copy them.

Loose vertices are ignored – they will not be turned into single-point splines.

Attributes, both named and unnamed ones, are transferred to the resulting splines.
If there is a `radius` attribute, it will be applied as such,
although you may find it more convenient to use the
[Set Curve Radius Node](../../curve/write/set_curve_radius.xhtml) for this.
user: Show practical ways to work with GeometryNodeInputMeshFaceArea(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInputMeshFaceArea(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.GeometryNodeInputMeshFaceArea(*GeometryNode*)
:   Calculate the surface area of a mesh’s faces

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Volume
:   Standard geometry input.

Resolution Mode
:   Mode for how the resolution of the final mesh is controlled.

    Grid:
    :   This makes the resolution dependent on the resolution of the grid that is converted.
        Higher resolution grids result in a higher resolution mesh.
        In many cases, that is the most efficient mode.

    Voxel Amount:
    :   Specifies the approximate resolution of the final mesh.
        The voxel size is adapted to the size of the entire volume.

    Voxel Size:
    :   Use a fixed resolution that does not change when the volume changes.

Voxel Amount
:   Specifies the approximate resolution of the final mesh.
    The voxel size is adapted to the size of the entire volume.

Voxel Size
:   Use a fixed resolution that does not change when the volume changes.

Threshold
:   Voxels with a larger value are considered to be inside the mesh.
    The mesh will be generated on the boundary of inside and outside voxels.
    This is also called “iso value”.

Adaptivity
:   Reduces the final face count by simplifying geometry where detail is not needed.
    This is similar to decimating the final to reduce resolution where it is not needed.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Value
:   Special gizmo value socket.
    Everything that linked into this socket will be modified when the gizmo is modified.

Position
:   Position of the gizmo in the local space of the object.

Rotation
:   Local orientation of the gizmo.
user: What is Instance on Elements Node and how is it used in Blender Python scripting?

assistant: # Instance on Elements Node

[image reference removed]

The *Instance on Elements* node creates instances of an object, collection, or geometry
on selected elements of an input geometry.
It can be used to distribute instances on points, edges, faces, or face corners,
providing flexibility for procedural instancing workflows.
user: Show practical ways to work with Select More/Less in a Blender add-on or script – include code.

assistant: Expands or contracts the selection based on the currently selected control points.

More
:   Adds the neighbors of the selected control points to the selection.

Less
:   Removes the control points with at least one unselected neighbor from the selection.
user: How do I use Node Socket Type Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Node Socket Type Items

CUSTOM:
:   Custom.

VALUE:
:   Value.

INT:
:   Integer.

BOOLEAN:
:   Boolean.

VECTOR:
:   Vector.

ROTATION:
:   Rotation.

MATRIX:
:   Matrix.

STRING:
:   String.

RGBA:
:   RGBA.

SHADER:
:   Shader.

OBJECT:
:   Object.

IMAGE:
:   Image.

GEOMETRY:
:   Geometry.

COLLECTION:
:   Collection.

TEXTURE:
:   Texture.

MATERIAL:
:   Material.

MENU:
:   Menu.

BUNDLE:
:   Bundle.

CLOSURE:
:   Closure.
user: Explain Render in complete detail according to the official Blender documentation.

assistant: Space
:   Specifies how volume density and step size are computed.

    Object:
    :   Keeps volume *Density* and *Detail* the same regardless of object scale.

    World:
    :   Specify *Step Size* and *Density* in world space.

Clipping Cycles Only
:   Value under which voxels are considered empty space to optimize rendering.

Precision Cycles Only
:   Specifies volume data precision. Lower values reduce memory consumption at the cost of detail.

    Full:
    :   Full float (Use 32 bit for all data).

    Half:
    :   Half float (Use 16 bit for all data).

    Variable:
    :   Automatically use less precision for less noticeable areas.

Velocity Grid Cycles Only
:   The name of the grid that contains voxel velocities, for calculating motion blur.
    This can be the name of a single grid containing 3D vectors,
    or a prefix of three separate grids containing scalar values.
    In the latter case, the X grid should have a name suffix of `x`, `.x` or `_x`,
    with similar conventions for the Y and Z grids.

Velocity Unit Cycles Only
:   Whether the velocity grid(s) specify distances per frame or per second.

Velocity Scale Cycles Only
:   A custom multiplier to apply to the velocities in the VDB.
user: Explain WORKSPACE_UL_addons_items(UIList) in complete detail according to the official Blender documentation.

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

assistant: Segment Coordinates
:   Segment coordinates for texture mapping within each radial segment.

Segment ID
:   Unique ID for every radial segment startiing at 0 and increasing counterclockwise by 1 for every for each segment.

Segment Width
:   Relative width of each radial segment. May be used to scale textures to fit into each segment.

Segment Rotation
:   Counterclockwise rotation of each segment coordinate system. May be used to align the rotation of the textures of each segment.
user: What is Selection and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| `LMB` | Select |
| `Ctrl`-`A` | Select All |
| `Shift`-`Ctrl`-`A` | Deselect All |
| `Ctrl`-`I` | Select Inverse |
| `Up` | Select More |
| `Down` | Select Less |
| Double `LMB` | Select Loop |
| Double `Alt`-`LMB` | Select Ring |
| `Ctrl` `L` | Select Linked |
user: Give a detailed overview of Geometry to Instance Node: syntax, arguments, return values, common patterns.

assistant: # Geometry to Instance Node

[image reference removed]

The *Geometry to Instance* node turns every connected input geometry into an instance.
Visually, the node has a similar result as the [Join Geometry Node](join_geometry.xhtml),
but it outputs the result as separate instances instead. The geometry data itself isn’t actually
joined.

The node can be used in combination with the *Pick Instances* option in the
[Instance on Points Node](../instances/instance_on_points.xhtml), as a way to pick
between geometry generated in the node tree (as opposed to picking from separate
instances from the [Collection Info Node](../input/scene/collection_info.xhtml), for example).
user: Describe Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: A Bézier curve can be edited by transforming the locations of both control points and handles.
NURBS curve on the other hand have only control points.

Move, Rotate, Scale
:   Like other elements in Blender, curve control points and handles can be
    moved, rotated, or scaled as described in
    [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml).

To Sphere, Shear, Bend, Push/Pull, Warp, Randomize
:   The transform tools are described in
    the [Transformations](../../meshes/editing/mesh/transform/index.xhtml) sections.

Move/Scale Texture Space
:   Like other objects, curves have textures spaces which can be
    [edited](../../meshes/uv/uv_texture_spaces.xhtml#properties-texture-space-editing).

### Radius

Controls the width of the extrusion along the “spinal” curve.
The radius will be interpolated from point to point (you can check it with the normals).
The *Radius* of the points is set using the *Radius* transform tool. Or in the Sidebar *Transform* panel.

[image reference removed]

One control point radius set to zero.
user: Explain faces.super_face in complete detail according to the official Blender documentation.

assistant: Will create a face system based on the bones child to the parent that has the property set on it.

Requirement: All the face bones bundled in the `faces.super_face` sample had to be present and
child of the master bone that has the Rigify type *face* property set.
user: How do I use NodeTreeInterfaceSocketVectorVelocity(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketVectorVelocity(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.NodeTreeInterfaceSocketVectorVelocity(*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 Active Spline, preserving all code examples.

assistant: # Active Spline

The *Active Spline* panel is used in Edit Mode to control properties of the currently selected spline.

Common Options

Cyclic U
:   Closes the active spline.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   Default NURBS curve. | ../../../_images/modeling_curves_properties_active-spline_nurbs-cyclic.png   A NURBS curve with Cyclic applied. |

Resolution U
:   Alters the [resolution](shape.xhtml#bpy-types-curve-resolution-u)
    of each segment by changing the number of subdivisions.

Smooth
:   Use [Smooth Shading](../../meshes/editing/mesh/shading.xhtml#modeling-meshes-editing-normals-shading) for any 3D geometry.
user: Explain Vertex Paint Brushes in complete detail according to the official Blender documentation.

assistant: # Vertex Paint Brushes

Brushes for Grease Pencil *Vertex Paint* mode bundled in the *Essentials* library.

Paint Point Color
:   Paints a specified color over the object.

Blur Point Color
:   Smooths out the colors of adjacent vertices. In this mode the Color
    Value is ignored. The strength defines how much the colors are blurred.

Average Point Color
:   Smooths color by painting the average resulting color from all colors under the brush.

Smear Point Color
:   Smudges colors by grabbing the colors under the brush and “dragging” them.
    This can be imagined as a finger painting tool.

Replace Point Color
:   Change the color only to the stroke points that already have a color applied.
user: Provide the full official documentation entry for 3D Markers to Mesh, preserving all code examples.

assistant: Creates a mesh which vertices matches positions of reconstructed tracks.
It is required to have motion solved first before using this operator.
Only tracks from the current tracking object will be used.
The intention of this operator is to give a nice starting point for a manual mesh reconstruction.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: Use the panel in Sidebar of the node editor or press `Shift`-`W` to bring up the quick access menu. You can also
look up the shortcut list in the add-on preferences panel.

[image reference removed]

You can access most functions from the sidebar panel or quick access menu.
user: Provide the full official documentation entry for MeshSequenceCacheModifier(Modifier), preserving all code examples.

assistant: # MeshSequenceCacheModifier(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.MeshSequenceCacheModifier(*Modifier*)
:   Cache Mesh

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

    object_path
    :   Path to the object in the Alembic archive used to lookup geometric data

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

    read_data
    :   Data to read from the cache

        Type:
        :   enum set in {`'VERT'`, `'POLY'`, `'UV'`, `'COLOR'`, `'ATTRIBUTES'`}, default {`'ATTRIBUTES'`, `'COLOR'`, `'POLY'`, `'UV'`, `'VERT'`}

    use_vertex_interpolation
    :   Allow interpolation of vertex positions

        Type:
        :   boolean, default True

    velocity_scale
    :   Multiplier used to control the magnitude of the velocity vectors for time effects

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: To toggle between the two projections for the 3D Viewport, select
View ‣ Perspective/Orthographic or use the shortcut
`Numpad5`. Changing the projection for a 3D Viewport does not affect
the way the scene will be rendered. Rendering is in perspective by default.
If you need to create an orthographic rendering, select the camera, go to
the Camera tab in the [Properties editor](../../properties_editor.html),
and set the Type in the Lens panel to *Orthographic*.
user: Provide the full official documentation entry for Should I Translate... ?, preserving all code examples.

assistant: ### Maybe

Hyperlinks
:   May be translated, but only as an addition, not as a replacement.
    Keep the original link text and add the translation alongside.
    See also [Adding Text](#adding-text).

Technical Terms
:   Translate only if the localized expression is commonly used and well understood.
    Otherwise, keep the English term.
    See also [Technical Terms](#technical-terms).

Unclear Text
:   If you are not sure you understood the meaning, mark the text as *fuzzy* and/or add a translator comment.
    Another translator may be able to clarify it.

UI Elements
:   UI elements should use the same translation as in Blender’s user interface.
    If the UI element has not yet been translated, keep the English term
    and add the translation in parentheses.

### Never

Images
:   You probably will not find the original scene if it is a screenshot of a file and it is too much load on the server
    (and too much work for you).
user: Explain RetimingKeys(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # RetimingKeys(bpy_struct)

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

*class* bpy.types.RetimingKeys(*bpy_struct*)
:   Collection of RetimingKey

    add(*\**, *timeline_frame=0*)
    :   Add retiming key

        Parameters:
        :   **timeline_frame** (*int in* *[**-1048574**,* *1048574**]**,* *(**optional**)*) – Timeline Frame

        Returns:
        :   New RetimingKey

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

    reset()
    :   Remove all retiming keys

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

assistant: # GeometryNodeGridVoxelize(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.GeometryNodeGridVoxelize(*GeometryNode*)
:   Remove sparseness from a volume grid by making the active tiles into voxels

    data_type
    :   Node socket data type

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # MeshLoopColorLayer(bpy_struct)

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

*class* bpy.types.MeshLoopColorLayer(*bpy_struct*)
:   Layer of vertex colors in a Mesh data-block

    active
    :   Sets the layer as active for display and editing

        Type:
        :   boolean, default False

    active_render
    :   Sets the layer as active for rendering

        Type:
        :   boolean, default False

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

    name
    :   Name of Vertex color layer

        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: How do I use Cycles and EEVEE Differences in Blender? Include parameters, examples, warnings and best practices.

assistant: The number of iterations in *Cycles* must evaluate to a constant value.
This means the number of iterations can’t be driven by [Input Nodes](../input/index.html) or [Texture Nodes](../textures/index.html).

[image reference removed]

Error shown when *Cycles* is selected as the active *Render Engine*.

*EEVEE* doesn’t have this limitation, so the number of iterations can be driven by any type of node.
user: What is Hue/Saturation Tips and how is it used in Blender Python scripting?

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: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`ClothSettings.effector_weights`](bpy.types.ClothSettings.html#bpy.types.ClothSettings.effector_weights "bpy.types.ClothSettings.effector_weights") - [`DynamicPaintSurface.effector_weights`](bpy.types.DynamicPaintSurface.html#bpy.types.DynamicPaintSurface.effector_weights "bpy.types.DynamicPaintSurface.effector_weights") - [`FluidDomainSettings.effector_weights`](bpy.types.FluidDomainSettings.html#bpy.types.FluidDomainSettings.effector_weights "bpy.types.FluidDomainSettings.effector_weights") | - [`ParticleSettings.effector_weights`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.effector_weights "bpy.types.ParticleSettings.effector_weights") - [`RigidBodyWorld.effector_weights`](bpy.types.RigidBodyWorld.html#bpy.types.RigidBodyWorld.effector_weights "bpy.types.RigidBodyWorld.effector_weights") - [`SoftBodySettings.effector_weights`](bpy.types.SoftBodySettings.html#bpy.types.SoftBodySettings.effector_weights "bpy.types.SoftBodySettings.effector_weights") |
user: Explain ShaderNodeLayerWeight(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeLayerWeight(ShaderNode)

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

*class* bpy.types.ShaderNodeLayerWeight(*ShaderNode*)
:   Produce a blending factor depending on the angle between the surface normal and the view direction.
    Typically used for layering shaders with the Mix Shader node

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

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Linux, graphics drivers are usually installed as a package by your Linux distribution. Installing the latest
drivers is typically done by upgrading packages or the distribution as a whole. Some distributions provide multiple
packages for multiple drivers versions, giving you the choice to install newer versions.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   Standard geometry input.

Capture Items
:   The fields to store. Inputs can be added by connecting another node’s output
    to this node’s blank input, or by using the *Capture Items* list in the node’s
    *Properties* panel.

    The inputs can be renamed by clicking them with `Ctrl`-`LMB` in the node
    itself or in its *Capture Items* list. The latter also accepts double clicking.
user: How do I use Strip Proxy & Timecode in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Contains strip-specific proxy settings. The checkbox in the header can be used to
enable/disable proxy generation.

Custom Proxy
:   Directory
    :   By default, all generated proxy videos are stored to
        the folder `<path of original footage>/BL_proxy/<clip name>`,
        but this can be changed to a custom directory using this option.

    File
    :   Allows you to use preexisting proxies.

Resolutions
:   The resolution(s) of the proxy videos to generate; multiple sizes can be selected.

Overwrite
:   Whether to overwrite existing proxy files or keep them.

Quality
:   Controls the level of lossy compression applied to the image, expressed as a percentage.
    Lossy compression reduces file size by discarding some image data, which may result in a loss of detail.

    - **0%**: Maximum compression, producing the smallest file size but the most noticeable quality loss.
    - **100%**: No compression, preserving full image quality at the cost of a larger file size.

[Timecode](../../../../glossary/index.xhtml#term-Timecode) Index
:   When you are working with footage directly copied from a camera without preprocessing it,
    there might be numerous artifacts, mostly due to seeking to a given frame in the sequence.
    This happens because such footage usually does not have correct frame rate values in the file header.
    This issue can still arise when the source clip has the same frame rate as the scene settings.
    In order for Blender to correctly calculate the frames and frame rate there are two possible solutions:

    1. Preprocess your video with e.g. MEncoder to repair the file header and insert the correct keyframes.
    2. Use the Timecode Index option in Blender.

    None:
    :   Ignore generated timecodes, seek in movie stream based on calculated timestamp.

    Record Run:
    :   Seek based on timestamps read from movie stream, giving the best match between scene and movie times.

    Record Run No Gaps:
    :   Effectively convert movie to an image sequence,
        ignoring incomplete or dropped frames, and changes in frame rate.
user: Provide the full official documentation entry for Plane, preserving all code examples.

assistant: The left bottom corner of the plane does have X/Y axis (X is red, Y is green) to
help distinguishing orientation of the plane in space.

It is likely that corner of the plane object need to be manually adjusted.
To do this sliding individual corners with mouse `LMB` or general transform tools
`G`, `R`, `S` could be used.

Adjusting plane corners will keep it following the plane defined by tracks it was originally created from.
user: Describe Viewport Shading from the Blender manual or Python API, including usage steps and snippets.

assistant: # Viewport Shading

Blender offers different shading modes for helping with different tasks.
For example, Solid shading is well-suited for modeling, while Rendered
is useful for setting up lighting.

The radio buttons let you change the shading mode, while the drop-down button
opens a popover with additional options described below.

Pressing `Z` opens a pie menu for changing the shading mode.
Pressing `Shift`-`Z` switches between the current shading mode and Wireframe.
user: Explain Getting Started in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Default UV editing workspace.

By default, meshes are not created with UVs. First you must map the faces, then
you can [edit them](../editing.xhtml).
The process of unwrapping your model is done within Edit Mode in the 3D Viewport.
This process creates one or more UV Islands in the [UV Editor](../../../../editors/uv/index.xhtml#editors-uv-index).

To begin, choose the *UV Editing* [workspace](../../../../interface/window_system/workspaces.xhtml)
from the selection list at the top of your screen in the Preferences header.
This sets one of the areas to show you the UV Editor, and the other area to the 3D Viewport.

Enter *Edit Mode*, as all unwrapping is done in Edit Mode.
You can be in vertex, face, or edge selection mode.

### Workflow

The general workflow is as follows, but know that different models may require
different approaches to unwrapping:

1. Mark Seams if necessary. See more about [marking seams](seams.xhtml).
2. Select mesh faces in the 3D Viewport.
3. Select a UV mapping method from the UV ‣ Unwrap menu or
   the UV menu in the 3D Viewport.
4. Adjust the unwrap settings in the [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
5. Add a test image to see if there will be any distortion.
   See [Applying Images to UVs](../applying_image.xhtml).
6. Adjust UVs in the UV editor. See [Editing UVs](../editing.xhtml).
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Screw modifier.

Angle
:   Degrees for a single helix revolution.

Screw
:   The height of one helix iteration.

Iterations
:   Number of revolutions.

Axis
:   The axis along which the helix will be built.

Axis Object
:   The name of an object to define the axis direction.

    Object Screw
    :   Use the distance from the *Axis Object* to define the height of one helix iteration.

Steps Viewport
:   Number of steps used for a single revolution displayed in the 3D Viewport.

Render
:   As above, but used during render time. Increase to improve quality.

Merge
:   Merge vertices that lie on the axis of rotation.
    Use this to close off end points with a triangle fan.

    Merge Distance
    :   Vertices under this distance to the axis are merged.

Stretch UVs
:   Stretch the UV coordinates from (0.0 to 1.0) when UVs are present.

### Normals

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input geometry is not preserved.

Calculate Order
:   Order of edges is calculated to avoid problems with normals and shading. Only needed for meshes, not curves.

Flip
:   Flip normals direction.
user: Provide the full official documentation entry for Trace, preserving all code examples.

assistant: CPU Only

We support the `trace(point pos, vector dir, ...)` function,
to trace rays from the OSL shader. The “shade” parameter is not supported currently,
but attributes can be retrieved from the object that was hit using the
`getmessage("trace", ..)` function. See the OSL specification for details on how to use this.

This function cannot be used instead of lighting;
the main purpose is to allow shaders to “probe” nearby geometry,
for example to apply a projected texture that can be blocked by geometry,
apply more “wear” to exposed geometry, or make other ambient occlusion-like effects.