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

assistant: [image reference removed]

UV Map
:   Which UV map to modify; if not set it defaults to the active rendering layer.

UV Center
:   The center point of the UV map to use when applying scale or rotation.
    With (0, 0) at the bottom left and (1, 1) at the top right.

Axis U, V
:   The axes to use when mapping the 3D coordinates into 2D.

Object From, To
:   The two objects used to define the transformation. See [Usage](#usage) below.

Vertex Group
:   The vertex group can be used to scale the influence of the transformation per vertex.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

### Transform

Offset
:   Amount to move the UV map.

Scale
:   Amount to scale the UV map.

Rotation
:   Amount to rotate the UV map.
user: How do I use Object Origin in Blender? Include parameters, examples, warnings and best practices.

assistant: # Object Origin

Each object has an origin point. The location of this point determines where the object is located in 3D space.
When an object is selected, a small dot appears, denoting the origin point.
The location of the origin point is important when translating, rotating or scaling an object.
See [Pivot Points](../../editors/3dview/controls/pivot_point/index.xhtml) for more.

The color of the origin changes based on the [selection](selecting.xhtml)
state of the object.

Yellow:
:   Object is active.

Orange:
:   Object is selected, but not active.

White:
:   Object is not linked and not selected.

Turquoise:
:   Object is linked.

Light Turquoise:
:   Object is selected, linked, but not active.
user: Explain StripElements(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # StripElements(bpy_struct)

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

*class* bpy.types.StripElements(*bpy_struct*)
:   Collection of StripElement

    append(*filename*)
    :   Push an image from ImageStrip.directory

        Parameters:
        :   **filename** (*string**,* *(**never None**)*) – Filepath to image

        Returns:
        :   New StripElement

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

    pop(*index*)
    :   Pop an image off the collection

        Parameters:
        :   **index** (*int in* *[**-inf**,* *inf**]*) – Index of image to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Geometry and how is it used in Blender Python scripting?

assistant: Display UVs
:   Show the active UV map as an overlay in the UV Editor.

UV Face Opacity
:   Adjust the opacity of face fill colors in UV overlays.

UV Opacity Edit Mode
:   Opacity of edges and faces.

Display As Edit Mode
:   Control how edges are shown.

    Outline:
    :   Display edges in gray with a black outline.

    Dash:
    :   Display edges as dashed black-gray lines.

    Black:
    :   Display edges in black.

    White:
    :   Display edges in white.

Modified Edges Edit Mode
:   Additionally show the edges as they look after applying modifiers (in gray).

Faces Edit Mode
:   Display faces over the image.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.selected_movieclip_tracks`](bpy.context.html#bpy.context.selected_movieclip_tracks "bpy.context.selected_movieclip_tracks") - [`MovieTracking.tracks`](bpy.types.MovieTracking.html#bpy.types.MovieTracking.tracks "bpy.types.MovieTracking.tracks") - [`MovieTrackingObject.tracks`](bpy.types.MovieTrackingObject.html#bpy.types.MovieTrackingObject.tracks "bpy.types.MovieTrackingObject.tracks") - [`MovieTrackingObjectPlaneTracks.active`](bpy.types.MovieTrackingObjectPlaneTracks.html#bpy.types.MovieTrackingObjectPlaneTracks.active "bpy.types.MovieTrackingObjectPlaneTracks.active") - [`MovieTrackingObjectTracks.active`](bpy.types.MovieTrackingObjectTracks.html#bpy.types.MovieTrackingObjectTracks.active "bpy.types.MovieTrackingObjectTracks.active") - [`MovieTrackingObjectTracks.new`](bpy.types.MovieTrackingObjectTracks.html#bpy.types.MovieTrackingObjectTracks.new "bpy.types.MovieTrackingObjectTracks.new") | - [`MovieTrackingStabilization.rotation_tracks`](bpy.types.MovieTrackingStabilization.html#bpy.types.MovieTrackingStabilization.rotation_tracks "bpy.types.MovieTrackingStabilization.rotation_tracks") - [`MovieTrackingStabilization.tracks`](bpy.types.MovieTrackingStabilization.html#bpy.types.MovieTrackingStabilization.tracks "bpy.types.MovieTrackingStabilization.tracks") - [`MovieTrackingTracks.active`](bpy.types.MovieTrackingTracks.html#bpy.types.MovieTrackingTracks.active "bpy.types.MovieTrackingTracks.active") - [`MovieTrackingTracks.new`](bpy.types.MovieTrackingTracks.html#bpy.types.MovieTrackingTracks.new "bpy.types.MovieTrackingTracks.new") - [`UILayout.template_marker`](bpy.types.UILayout.html#bpy.types.UILayout.template_marker "bpy.types.UILayout.template_marker") |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input.

Minimum
:   Determines the lowest values that are considered foreground.
    (Which is supposed to be – relatively – light: from this value to 1.0.)

Maximum
:   Determines the highest values that are considered to be background objects.
    (Which is supposed to be – relatively – dark: from 0.0 to this value.)
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: The *Evaluate Closure* node does not have functional properties, but its input and output interface can be managed in
the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the node as defining a closure signature to be used by other closure nodes. Ensures consistent input and output
    definitions across related closures.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click to rename.

Add Item
:   Add a new input socket to the closure interface.

Remove Item
:   Delete the selected input socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

List of output sockets
:   Displays one entry per output socket. Double-click to rename.

Add Item
:   Add a new output socket to the node.

Remove Item
:   Delete the selected output socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.
user: What is ShaderNodeInvert(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeInvert(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.ShaderNodeInvert(*ShaderNode*)
:   Invert a color, producing a negative

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

assistant: Feather
:   Use or ignore feather points defined for splines see [Mask Feathers](../../../movie_clip/masking/scurve.xhtml#mask-feather) for more details.

Size Source
:   Where to get the mask size from for aspect/size information.

    Scene Size:
    :   Will give an image the size of the render resolution for the scene,
        scaling along when rendering with different resolutions.

    Fixed:
    :   Gives a fixed size in pixels.

    Fixed/Scene:
    :   Gives a size in pixels that still scales along when changing the render resolution percentage in the scene.

### Motion Blur

For animated masks, creating a motion blurred mask from the surrounding frames.

Samples
:   Number of motion blur samples.
    Higher values result in smoother and more accurate blur, but increase processing time.

Shutter
:   Duration of the motion blur in seconds, corresponding to the exposure time simulated for each frame.
user: Describe Euler Modes from the Blender manual or Python API, including usage steps and snippets.

assistant: The axes system used for performing Euler rotations is the so called Euler gimbal.
A gimbal is a particular set of three axes.
The special thing about this is that the axes have a hierarchical relationship between them:
one of the axes is at the top of the hierarchy, and has one of the other two axes as its immediate child;
at the same time, this child axis is the parent of the remaining axis, the one at the very bottom of the hierarchy.

Which axis is on top, which one in the middle and which at the bottom,
depends on the particular Euler gimbal: there are six types of them, as there
are six possible combinations: XYZ, XZY, YXZ, YZX, ZXY and ZYX Euler rotation modes.
These modes are named using the letters of the axes in order, starting from
the axis at the bottom of the hierarchy, and finishing with the one on top.

The main problem of these systems comes when they lose their relative perpendicularity.
And this happens when the axis in the middle rotates, causing the axis at the bottom to
rotate with it. It keeps getting worse when this bottom axis approaches 90° (or equivalent angles).
In that case, it will remain aligned with the axis on top of the hierarchy. In that moment
we have just lost one axis of rotation. This can cause discontinuous interpolations when animating.
This particular loss of axis is known as the “gimbal lock”.

One advantage of this mode is that animation curves are easy to understand and edit.
However, special attention must be done when the middle axis approaches values close to 90° (or equivalent angles).
user: Describe Naming Conventions from the Blender manual or Python API, including usage steps and snippets.

assistant: Naming conventions in Blender are not only useful for you in finding the right bone,
but also to tell Blender when any two of them are counterparts.

In case your armature can be mirrored in half (i.e. it is bilaterally symmetrical),
it is worthwhile to stick to a left/right naming convention.
This will enable you to use some tools that will probably save you time and effort
(like the *X-Axis Mirror* editing tool).

[image reference removed]

An example of left/right bone naming in a simple rig.

1. First you should give your bones meaningful base-names,
   like “leg”, “arm”, “finger”, “back”, “foot”, etc.
2. If you have a bone that has a copy on the other side (a pair),
   like an arm, give it one of the following separators:

   - Left/right separators can be either the second position
     “L**_**calf_bone” or last-but-one “calf_bone**.**R”.
   - If there is a lower or upper case “L”, “R”, “left” or “right”, Blender handles the counterpart correctly.
     See below for a list of valid separators.
     Pick one and stick to it as close as possible when rigging; it will pay off.

   Examples of valid separators:

   - (nothing): handLeft –> handRight
   - “_” (underscore): hand**_**L –> hand**_**R
   - “.” (dot): hand**.**l –> hand**.**r
   - “-” (dash): hand**-**l –> hand**-**r
   - “ “ (space): hand LEFT –> hand RIGHT
3. Before Blender handles an armature for mirroring or flipping,
   it first removes the number extension, e.g. “.001”.
4. You can copy a bone named “blah.L” and flip it over using [Flip Names](#bpy-ops-armature-flip-names).
   Blender will name the copy “blah.L.001” and flipping the name will give you “blah.R”.
user: Explain Dt Method Poly Items in complete detail according to the official Blender documentation.

assistant: # Dt Method Poly Items

TOPOLOGY:
:   Topology.

    Copy from identical topology meshes.

NEAREST:
:   Nearest Face.

    Copy from nearest face (using center points).

NORMAL:
:   Best Normal-Matching.

    Copy from source face which normal is the closest to destination one.

POLYINTERP_PNORPROJ:
:   Projected Face Interpolated.

    Interpolate all source polygons intersected by the projection of destination one along its own normal.
user: Show practical ways to work with ParticleSettingsTextureSlots(bpy_struct) in a Blender add-on or script – include code.

assistant: # ParticleSettingsTextureSlots(bpy_struct)

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

*class* bpy.types.ParticleSettingsTextureSlots(*bpy_struct*)
:   Collection of texture slots

    *classmethod* add()
    :   add

        Returns:
        :   The newly initialized mtex

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

    *classmethod* create(*index*)
    :   create

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

        Returns:
        :   The newly initialized mtex

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

    *classmethod* clear(*index*)
    :   clear

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

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

assistant: # ObjectSolverConstraint(Constraint)

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

*class* bpy.types.ObjectSolverConstraint(*Constraint*)
:   Lock motion to the reconstructed object movement

    camera
    :   Camera to which motion is parented (if empty active scene camera is used)

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

    clip
    :   Movie Clip to get tracking data from

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

    object
    :   Movie tracking object to follow

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

    set_inverse_pending
    :   Set to true to request recalculation of the inverse matrix

        Type:
        :   boolean, default False

    use_active_clip
    :   Use active clip defined in scene

        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: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

[image reference removed]

The Outliner editor.

The *Outliner* shows the content of the blend-file in a tree. You can use it to:

- Get an overview of the data in the scene.
- Select and deselect objects.
- Make objects unselectable or invisible in the 3D Viewport.
- Exclude objects from rendering.
- Duplicate objects.
- Delete objects.
- Manage parent/child relationships and [collections](../../scene_layout/collections/introduction.html).

Items with an arrow on the left can be expanded. Click it with `LMB` to expand a single item,
drag `LMB` to expand multiple items, or click `Shift`-`LMB` to expand an item recursively.
user: Explain Bokeh Image Node in complete detail according to the official Blender documentation.

assistant: # Bokeh Image Node

[image reference removed]

The *Bokeh Image* node generates a special input image for use with
the [Bokeh Blur](../filter/blur/bokeh_blur.xhtml) filter node.

The *Bokeh Image* node is designed to create a reference image which simulates optical parameters
such as aperture shape and lens distortions which have important impacts on bokeh in real cameras.
user: What is Symmetry and how is it used in Blender Python scripting?

assistant: # Symmetry

Mirror
:   Mirror the brush strokes across the selected local axes.
    Note that if you want to alter the directions the axes point in,
    you must rotate the model in Edit Mode and not in Object Mode.

Lock
:   These three buttons allow you to block any modification/deformation
    of your model along selected local axes, while you are sculpting it.

Tiling
:   Using this option allows you to seamlessly tile your strokes along the given axes.
    This allows to create repeating patterns.

Feather
:   Reduces the strength of the stroke where it overlaps the planes of symmetry.

Radial X, Y, Z
:   These settings allow for radial symmetry in the desired axes.
    The number determines how many times the stroke will be repeated
    within 360 degrees around the central axes.

Tile Offset X, Y, Z
:   The offset allows the option to alter the tile size along all three axes.
    The default tile size is set to one unit.

Symmetrize

Direction
:   Determines which direction the model will be symmetrized.

Merge Distance
:   A parameter of the *Symmetrize* operator to control
    the distance within which symmetrical vertices are merged.

Symmetrize
:   Uses direction orientation to symmetrize. Since Dyntopo adds
    details dynamically it may happen that the model becomes asymmetric,
    so this a good tool for that.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.selected_editable_keyframes`](bpy.context.html#bpy.context.selected_editable_keyframes "bpy.context.selected_editable_keyframes") - [`FCurve.keyframe_points`](bpy.types.FCurve.html#bpy.types.FCurve.keyframe_points "bpy.types.FCurve.keyframe_points") | - [`FCurveKeyframePoints.insert`](bpy.types.FCurveKeyframePoints.html#bpy.types.FCurveKeyframePoints.insert "bpy.types.FCurveKeyframePoints.insert") - [`FCurveKeyframePoints.remove`](bpy.types.FCurveKeyframePoints.html#bpy.types.FCurveKeyframePoints.remove "bpy.types.FCurveKeyframePoints.remove") |
user: Explain Vector Blur Node in complete detail according to the official Blender documentation.

assistant: # Vector Blur Node

[image reference removed]

The Vector Blur node is a fast method for simulating [Motion Blur](../../../../glossary/index.html#term-Motion-Blur) in compositing.
It uses the vector speed render pass to blur the image pixels in 2D.
user: Show practical ways to work with Translate Blender in a Blender add-on or script – include code.

assistant: # Translate Blender

Bring Blender closer to everyone! 🌎 By translating Blender’s user interface, you help artists and creators worldwide
work in their native language. No coding skills are needed—just a passion for Blender and the ability to translate.
Join the translation community today and make Blender truly global!

For more information, see the [Blender UI Translation Guide](https://developer.blender.org/docs/handbook/translating/translator_guide/).
user: Describe Selecting from the Blender manual or Python API, including usage steps and snippets.

assistant: # Selecting

By default, Blender uses `LMB` to select items.
This can be changed to `RMB` in the [Preferences](../editors/preferences/keymap.xhtml).

Blender has several selection tools that can be used across the different editors.

Most selection tools come in two variants, where one variant is available in the Toolbar
and the other in the *Select* menu. While the variants’ names are almost identical
(such as *Select Box* in the Toolbar versus *Box Select* in the menu),
the way they work is a bit different. New users coming from other applications
will find the Toolbar variants to be the most familiar.
user: How do I use Vertex Buffers in Blender? Include parameters, examples, warnings and best practices.

assistant: A *Vertex Buffer Object* (VBO) ([`gpu.types.GPUVertBuf`](gpu.types.html#gpu.types.GPUVertBuf "gpu.types.GPUVertBuf"))
is an array that contains the vertex attributes needed for drawing using a specific shader.
Typical vertex attributes are *location*, *normal*, *color*, and *uv*.
Every vertex buffer has a *Vertex Format* ([`gpu.types.GPUVertFormat`](gpu.types.html#gpu.types.GPUVertFormat "gpu.types.GPUVertFormat"))
and a length corresponding to the number of vertices in the buffer.
A vertex format describes the attributes stored per vertex and their types.

The following code demonstrates the creation of a vertex buffer that contains 6 vertices.
For each vertex 2 attributes will be stored: The position and the normal.

```
import gpu
vertex_positions = [(0, 0, 0), ...]
vertex_normals = [(0, 0, 1), ...]

fmt = gpu.types.GPUVertFormat()
fmt.attr_add(id="pos", comp_type='F32', len=3, fetch_mode='FLOAT')
fmt.attr_add(id="normal", comp_type='F32', len=3, fetch_mode='FLOAT')

vbo = gpu.types.GPUVertBuf(len=6, format=fmt)
vbo.attr_fill(id="pos", data=vertex_positions)
vbo.attr_fill(id="normal", data=vertex_normals)
```

This vertex buffer could be used to draw 6 points, 3 separate lines, 5 consecutive lines, 2 separate triangles, …
E.g. in the case of lines, each two consecutive vertices define a line.
The type that will actually be drawn is determined when the batch is created later.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Text wrapped around logo.

This was made by creating the Blender logo and text as separate objects.
The text was converted to a mesh and then warped around the Blender logo.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: [[image reference removed]](../../../_images/render_shader-nodes_input_object-info_example.png)

[[image reference removed]](../../../_images/render_cycles_render-settings_motion-blur_example-cubes.jpg)

[Example blend-file](https://archive.blender.org/wiki/2015/uploads/0/03/Blender2.65_motion_blur.blend).
user: Show practical ways to work with Blueprint in a Blender add-on or script – include code.

assistant: # Blueprint

The *Blueprint* modifier produces blueprint-like strokes using either circular,
elliptical, or square contours. A blueprint here refers to those lines drawn at the beginning
of free-hand drawing to capture the silhouette of objects with a simple shape such as circles,
ellipses and squares.

Shape
:   Which base shapes to use for this blueprint: *Circles*, *Ellipses* or *Squares*.

Rounds
:   How many rounds are generated, as if the pen draws the same stroke several times
    (i.e. how many times the process is repeated).

Random Radius, Center
:   For the *Circles* and *Ellipses* shapes.
    Adds some randomness to each round in the relevant aspect.
    Using more than one round with no randomness would be meaningless, as they would draw over each other exactly.

Backbone Length, Backbone
:   For the *Squares* shapes.
    The first adds some extra length to each edge of the generated squares (also affected by the second parameter).
    The second adds some randomness to the squares.

Note that the *Min 2D Length* feature from the *Strokes* settings is quite
handy here, to avoid the noise generated by small strokes…
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   The input geometry containing the original hair curves to duplicate.

Amount
:   The number of duplicates generated for each original curve.
    Higher values increase hair density.

Viewport Amount
:   Defines the percentage of *Amount* used for viewport display.
    Reducing this value improves performance in the viewport while keeping render results unaffected.

Radius
:   The maximum distance around each guide curve within which duplicates are placed.
    Larger values spread the duplicates further apart.

Distribution Shape
:   Controls how duplicates are distributed within the radius, from the center to the outer edge.
    Different shapes can produce uniform, clustered, or edge-biased distributions.

Tip Roundness
:   Adjusts the rounding of duplicate curves near their tips.
    Higher values make the distribution more circular and natural toward the ends.

Even Thickness
:   When enabled, keeps an even density across the radius of duplicates.
    When disabled, density may vary depending on the distribution pattern.

Seed
:   Sets the random seed for duplicate placement.
    Changing this value alters the random arrangement of duplicates while maintaining the same parameters.
user: Provide the full official documentation entry for Armature Structure, preserving all code examples.

assistant: # Armature Structure

[image reference removed]

Example of a very basic armature.

Armatures mimic real skeletons. They are made out of bones, which are (by default) rigid elements.
But you have more possibilities than with real skeletons: In addition to the “natural” rotation of bones,
you can also move and even scale them! And your bones do not have to be connected to each other;
they can be completely free if you want. However,
the most natural and useful setups imply that some bones are related to others, forming so-called “chains of bones”,
which create some sort of “limbs” in your armature, as detailed in [Chains of Bones](#chains-of-bones).
user: Explain Image Formats in complete detail according to the official Blender documentation.

assistant: This is the list of image file formats supported internally by Blender:

| Format | Channel Depth | Alpha | [Metadata](../../render/output/properties/metadata.xhtml) | [DPI](../../glossary/index.xhtml#term-DPI) | Extensions |
| --- | --- | --- | --- | --- | --- |
| JPEG | 8bit | ✗ | ✓ | ✓ | `.jpg` `.jpeg` |
| [OpenEXR](#openexr) | float 16, 32bit | ✓ | ✓ | ✓ | `.exr` |
| PNG | 8, 16bit | ✓ | ✓ | ✓ | `.png` |
| WebP | 8bit | ✓ | ✓ | ✗ | `.webp` |
| BMP | 8bit | ✓ | ✗ | ✓ | `.bmp` |
| [Cineon](#file-media-cineon-dpx) | 8, 10, 12, 16bit | ✓ | ✗ | ✗ | `.cin` |
| [DPX](#file-media-cineon-dpx) | 8, 10, 12, 16bit | ✓ | ✗ | ✗ | `.dpx` |
| Iris | 8, 16bit | ✓ | ✗ | ✗ | `.sgi` `.rgb` `.bw` |
| JPEG 2000 | 8, 12, 16bit | ✓ | ✗ | ✗ | `.jp2` `.jp2` `.j2c` |
| [Radiance HDR](#radiance-hdr) | float | ✓ | ✗ | ✗ | `.hdr` |
| Targa | 8bit | ✓ | ✗ | ✗ | `.tga` |
| Targa Raw | 8bit | ✓ | ✗ | ✗ | `.tga` |
| TIFF | 8, 16bit | ✓ | ✗ | ✓ | `.tif` `.tiff` |
user: Provide the full official documentation entry for Hold Split, preserving all code examples.

assistant: Like *Split*, it splits a strip in two distinct strips;
however you will not be able to drag the endpoints to show the frames past the split of each resulting strip.

Although you can adjust the [Hold Offset](../../../editors/video_sequencer/sequencer/sidebar/strip.html#sequencer-duration-hard)
number fields in the *Strip Info* panel.
user: Give a detailed overview of Transform Driver: syntax, arguments, return values, common patterns.

assistant: Control a property with an object’s transform.
In this example, the Y rotation of Object 2 will be driven by the X position of Object 1.
Starting from a simple setup with two objects:

1. Add a Driver to the *Rotation Y* property of the second object via the context menu or with `Ctrl`-`D`.

   [image reference removed]
2. Open the *Drivers Editor* and select the *Y Euler Rotation* property in the channels region.
3. Open the Sidebar region and select the *Drivers* tab.
4. Configure the driver to be the *Averaged Value* of a *Transform Channel* of the first object.

   [image reference removed]
5. Experiment with moving the first object and notice how it affects the Y rotation of the second object.
user: Explain Weight Paint in complete detail according to the official Blender documentation.

assistant: [image reference removed]

3D Viewport Mode selector: Weight Paint Mode.

Weight Paint Mode is selected from the *Mode* menu in the 3D Viewport header.
Once Weight Paint Mode is activated, the Toolbar of the 3D Viewport will change to Weight Paint Mode specific panels.
A red circle will appear and follow the location of the cursor in the 3D Viewport.
user: How do I use Move on Axis in Blender? Include parameters, examples, warnings and best practices.

assistant: Moves selected UV coordinates along a chosen axis by a specified distance.
This operator is designed for precise UV adjustments and supports multiple
movement modes. It is especially useful when combined with the number pad keys
for quick directional nudging.

Use the following shortcuts to move UVs directly from the keyboard:

- `Numpad8` / `Numpad2`: Move up or down.
- `Numpad4` / `Numpad6`: Move left or right.

Type
:   The movement unit type.

    Dynamic:
    :   Move using the active grid size.
        Holding `Ctrl` while pressing a number pad key activates this mode.

    Pixel:
    :   Move by pixel increments.
        Holding `Shift` while pressing a number pad key activates this mode.

    UDIM:
    :   Move by full UV tiles (1.0 UV unit).
        Using the number pad keys with no modifying keys uses this mode.

Axis
:   The axis along which to move the UVs.

    X Axis:
    :   Move vertices horizontally.

    Y Axis:
    :   Move vertices vertically.

Distance
:   The distance to move the UVs, measured in the selected unit type.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

### Unique

Deformation
:   The surface alteration that is used in the brush.

    Grab:
    :   Used to drag a group of vertices around.

    Bi-scale Grab:
    :   Like *Grab* but the falloff is more localized to the center of the brush.

    Tri-scale Grab:
    :   Like *Bi-scale Grab* but the falloff is more localized to the center of the brush.

    Scale:
    :   Displaces vertices away from the active vertex.

    Twist:
    :   Vertices are rotated around the active vertex.

Volume Preservation
:   Higher values preserve volumes more, but also lead to more bulging.
    (This value determines the poisson ratio for elastic deformation)
user: Explain Luma Waveform in complete detail according to the official Blender documentation.

assistant: This scope visualizes the luminosity (brightness) distribution of the image,
letting you see at a glance if there’s enough contrast and if any areas are
under- or overexposed.

The scope works by plotting a curve for each scanline in the current video frame.
Another way of saying this is that each pixel column in the luma waveform
is a brightness histogram of the corresponding pixel column in the frame.
Specifically:

- The horizontal position of a pixel in the waveform refers to a pixel column in the frame.
- The vertical position of a pixel in the waveform refers to a brightness value,
  going from 0 at the bottom to 1 at the top.
- The brightness of a pixel in the waveform indicates how many pixels in the above frame column
  have the above brightness. If no pixels in the frame column have this brightness, the
  waveform pixel is black. If at least three pixels in the frame column have this brightness,
  the waveform pixel is white.

When this scope is selected, you have the following option in
Sidebar ‣ View ‣ View Settings:

The examples below show two images and their corresponding luma waveforms.

|  |  |
| --- | --- |
| ../../../../_images/video-editing_preview_display-mode_luma-waveform-example-1.png   The various horizontal lines in the luma waveform match the uniform-colored lines of the picture. Note that the ‘gray 20%’ one-pixel width line (inside the yellow strip) is represented in the Luma waveform by a gray line. The two lines drawing an “X” are from the two monochrome gradients. Finally, the broken line matches the colored gradient at the bottom. | ../../../../_images/video-editing_preview_display-mode_luma-waveform-example-2.png   The curves are quite visible. We found a luma of 80-100% for the sky, a luma around 40% for the sea, and a luma of 10-20% for the mountains, growing around 40% for the sunny part. |
user: Give a detailed overview of VolumeDisplay(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # VolumeDisplay(bpy_struct)

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

*class* bpy.types.VolumeDisplay(*bpy_struct*)
:   Volume object display settings for 3D viewport

    density
    :   Thickness of volume display in the viewport

        Type:
        :   float in [1e-05, inf], default 0.0

    interpolation_method
    :   Interpolation method to use for volumes in solid mode

        - `LINEAR`
          Linear – Good smoothness and speed.
        - `CUBIC`
          Cubic – Smoothed high quality interpolation, but slower.
        - `CLOSEST`
          Closest – No interpolation.

        Type:
        :   enum in [`'LINEAR'`, `'CUBIC'`, `'CLOSEST'`], default `'LINEAR'`

    slice_axis
    :   - `AUTO`
          Auto – Adjust slice direction according to the view direction.
        - `X`
          X – Slice along the X axis.
        - `Y`
          Y – Slice along the Y axis.
        - `Z`
          Z – Slice along the Z axis.

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

    slice_depth
    :   Position of the slice

        Type:
        :   float in [0, 1], default 0.0

    use_slice
    :   Perform a single slice of the domain object

        Type:
        :   boolean, default False

    wireframe_detail
    :   Amount of detail for wireframe display

        - `COARSE`
          Coarse – Display one box or point for each intermediate tree node.
        - `FINE`
          Fine – Display box for each leaf node containing 8×8 voxels.

        Type:
        :   enum in [`'COARSE'`, `'FINE'`], default `'COARSE'`

    wireframe_type
    :   Type of wireframe display

        - `NONE`
          None – Don’t display volume in wireframe mode.
        - `BOUNDS`
          Bounds – Display single bounding box for the entire grid.
        - `BOXES`
          Boxes – Display bounding boxes for nodes in the volume tree.
        - `POINTS`
          Points – Display points for nodes in the volume tree.

        Type:
        :   enum in [`'NONE'`, `'BOUNDS'`, `'BOXES'`, `'POINTS'`], default `'NONE'`

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Blender is **not allowed to write to other blend-files** than the one you have currently open, or
the special .asset.blend files explained above. This means that to edit an asset, you have to
open its blend-file. Fortunately this is only a single click away, both in the Source List region of the Asset Browser
and in the asset context menu.
user: Provide the full official documentation entry for Brush Control, preserving all code examples.

assistant: These are the most common hotkeys for controlling the brush.

- Set brush size `F`
- Set brush strength `Shift`-`F`
- Rotate brush texture / Set brush weight `Ctrl`-`F`

After pressing these hotkeys, you can then either adjust the value interactively or by typing in numbers.
Move the mouse right or left to increase/reduce the value
(additionally with precision (`Shift`) and/or snapping (`Ctrl`) activated).
Finally confirm (`LMB`, `Return`) or cancel (`RMB`, `Esc`).

You can also invert the brush direction/effect by holding `Ctrl`.
user: Describe Strengths from the Blender manual or Python API, including usage steps and snippets.

assistant: Default
:   Goal weight/strength for all vertices when no *Vertex Group* is assigned.
    If you use a vertex group the weight of a vertex defines its goal.

Min/Max
:   When you use a vertex group, you can use the *Minimum* and *Maximum* to fine-tune (clamp) the weight values.
    The lowest vertex weight will become *Minimum*, the highest value becomes *Maximum*.
user: What is MovieTrackingPlaneTracks(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MovieTrackingPlaneTracks(bpy_struct)

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

*class* bpy.types.MovieTrackingPlaneTracks(*bpy_struct*)
:   Collection of movie tracking plane tracks

    active
    :   Active plane track in this tracking data object. Deprecated, use objects[name].plane_tracks.active

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

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

assistant: - **File Browser:**
  Preconfigured to display only relevant file types, making it easier to locate and import video, image,
  and audio files.
- **Preview:**
  The Preview area provides an interactive viewer where you can select, transform, and preview strips
  directly in the video output.
- **Sequencer:**
  The Sequencer is where you assemble and edit video, image, and sound strips.
- **Properties Editor:**
  Simplified to display only essential tabs: *Render*, *Output*, *Scene*, and *Strip Modifiers*.
user: How do I use Show All Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: While Blender logs operators in the Info editor,
this only reports operators with the `REGISTER` option enabled so as not to flood the *Info* view
with calls to `bpy.ops.view3d.smoothview` and `bpy.ops.view3d.zoom`.
Yet for testing it can be useful to see **every** operator called in a terminal,
do this by enabling the debug option either by passing the `--debug-wm` argument when starting Blender
or by setting [`bpy.app.debug_wm`](bpy.app.html#bpy.app.debug_wm "bpy.app.debug_wm") to `True` while Blender is running.
user: Give a detailed overview of Channel Key Node: syntax, arguments, return values, common patterns.

assistant: # Channel Key Node

[image reference removed]

The *Channel Key* node determines background objects from foreground objects by
the difference in the selected channel’s levels.

For example in the YUV [Color Model](../../../glossary/index.xhtml#term-Color-Model),
this node is useful when compositing stock footage of explosions (very bright)
which are normally shot against a solid, dark background.
user: Provide the full official documentation entry for Tool Settings, preserving all code examples.

assistant: Solver
:   Algorithm used to calculate the Boolean intersections.

    Exact:
    :   Uses a complex solver which offers the best results and has full
        support for overlapping geometry; however, this solver is much slower.

    Float:
    :   Uses a simple solver which offers the good performance;
        however, this solver lacks support for overlapping geometry.

    Manifold:
    :   Uses a solver that is usually fastest but only works on [Manifold](../../../glossary/index.xhtml#term-Manifold) meshes,
        (plus the special case of Difference with a plane).

Trim Mode
:   Geometry can be either added or removed by choosing one of these modes.

    Difference:
    :   Removes geometry, filling any holes that are created.

    Union:
    :   Creates a geometry and joins any intersections with existing geometry.

    Join:
    :   Similar to *Union* but joins the mesh as separate geometry,
        without performing any Boolean operations with existing geometry.

Shape Orientation
:   The method used to orientate the trimming shape.

    View:
    :   Use the view to orientate the trimming shape.

    Surface:
    :   Use the surface normal to orientate the trimming shape.

Extrude Mode
:   Fixed:
    :   Aligns new geometry orthogonally for 90 degree angles in depth.

    Project:
    :   Aligns new geometry with the perspective of the current view for a tapered result.

Use Cursor for Depth
:   Use cursor location and radius for the dimensions and position of the trimming shape.
    If not set, the tool uses the full depth of the object from the camera view.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Mesh
:   Standard geometry input.

Remove Custom Sharpness mode
:   If enabled, removes any existing custom normals or sharpness data.

Edge Sharpness Sharpness mode
:   Boolean field that defines whether an edge is marked sharp.
    True values result in sharp edges; false values result in smooth shading.

Face Sharpness Sharpness mode
:   Boolean field that defines whether a face is marked flat.
    True values result in flat-shaded faces; false values result in smooth shading.

Custom Normal Free mode, Tangent Space mode
:   The vector to store as the custom normal.
user: Explain Select Random in complete detail according to the official Blender documentation.

assistant: # Select Random

Adds random items to the selection. The [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last)
panel offers the following options:

Ratio
:   The ratio of items that should end up selected, e.g. 0.5 to select half of all items
    (that are not [hidden](../../../scene_layout/object/editing/show_hide.html)).

    Note that the existing selection is ignored: if half of the items are already selected,
    setting *Ratio* to 0.1 won’t deselect anything, nor will it select 10% of the unselected
    items. Instead, it always picks 10% of *all* visible items and adds them to the selection.

Random Seed
:   A number that influences which specific items get picked.

Action
:   Select:
    :   Add random items to the selection.

    Deselect:
    :   Remove random items from the selection.
user: Explain CacheFileLayers(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CacheFileLayers(bpy_struct)

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

*class* bpy.types.CacheFileLayers(*bpy_struct*)
:   Collection of cache layers

    active
    :   Active layer of the CacheFile

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

    new(*filepath*)
    :   Add a new layer

        Parameters:
        :   **filepath** (*string**,* *(**never None**)*) – File path to the archive used as a layer

        Returns:
        :   Newly created layer

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

    remove(*layer*)
    :   Remove an existing layer from the cache file

        Parameters:
        :   **layer** ([`CacheFileLayer`](bpy.types.CacheFileLayer.html#bpy.types.CacheFileLayer "bpy.types.CacheFileLayer"), (never None)) – Layer to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type