PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Cleanup from the Blender manual or Python API, including usage steps and snippets.

assistant: This panel contains operators and their settings which are needed to clean up bad tracks:
tracks which are not tracked long enough or which failed to reconstruct accurately.

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

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

Type
:   Several actions can be performed for bad tracks:

    Select:
    :   They can simply be selected.

    Delete Track:
    :   The whole track can be deleted.

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

Clean Tracks
:   See [Clean Tracks](../editing/track.xhtml#bpy-ops-clip-clean-tracks).

Filter Tracks
:   See [Filter Tracks](../editing/track.xhtml#bpy-ops-clip-filter-tracks).
user: Give a detailed overview of Distortion: syntax, arguments, return values, common patterns.

assistant: Distorted geometry can cause problems since the triangulation of a distorted n-gon is undefined.

Distortion is measured by faces which are not flat,
with parts of the face pointing in different directions.

Minimum/Maximum
:   Minimum/Maximum distortion to display.

[image reference removed]

Distorted Faces.
user: How do I use UVLoopLayers(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # UVLoopLayers(bpy_struct)

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

*class* bpy.types.UVLoopLayers(*bpy_struct*)
:   Collection of UV map layers

    active
    :   Active UV Map layer

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

    active_index
    :   Active UV map index

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

    new(*\**, *name='UVMap'*, *do_init=True*)
    :   Add a UV map layer to Mesh

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – UV map name
            - **do_init** (*boolean**,* *(**optional**)*) – Whether new layer’s data should be initialized by copying current active one, or if none is active, with a default UVmap

        Returns:
        :   The newly created layer

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

    remove(*layer*)
    :   Remove a UV map layer

        Parameters:
        :   **layer** ([`MeshUVLoopLayer`](bpy.types.MeshUVLoopLayer.html#bpy.types.MeshUVLoopLayer "bpy.types.MeshUVLoopLayer"), (never None)) – The 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
user: Describe Warning Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Warning Node

[image reference removed]

Outputs a custom message that can be referenced in the
[Warnings](../../modifiers/geometry_nodes.xhtml#modifiers-geometry-nodes-warnings) panel of the Geometry Nodes Modifier.

This allows node groups to communicate expectations about input values.

By default, warnings are propagated through all parent node groups.
However, this can be controlled using the [Warning Propagation](../../../interface/controls/nodes/node_editors.xhtml#bpy-types-node-warning-propagation) setting on each node.
user: Describe Pressure from the Blender manual or Python API, including usage steps and snippets.

assistant: Cloth pressure allows the simulation of soft-shelled objects
such as balloons or balls that are filled with a type of fluid.
This fluid is modeled as a gas; to emulate an incompressible liquid set
*Pressure Scale* as high as possible without breaking the simulation.
Cloth pressure can be enabled by toggling the checkbox in the *Pressure* panel header.

Pressure
:   The uniform pressure that is constantly applied to the mesh.
    This value is specified in units of *Pressure Scale*, and can be
    negative to simulate implosions or any other case where an object
    has outside pressure pushing inwards.

Custom Volume
:   Use the *Target Volume* parameter as the initial volume for the cloth,
    instead of computing it from the mesh itself.

Target Volume
:   The mesh volume where the inner/outer pressure will be the same.
    If set to zero, changes in the volume of the object will not affect pressure.

Pressure Scale
:   Ambient pressure (in kPa) that exists both inside and outside the object,
    balancing out when the volume matches the target. Increase the value to
    make the object resist changes in volume more strongly.

Fluid Density
:   Specifies the density of the fluid contained inside the object
    (in kg/liter = 1000 kg/m3, use 1 for water), used to generate
    a hydrostatic pressure gradient that simulates the weight of the fluid.
    If the value is negative, it instead models buoyancy from a surrounding fluid.

    The fluid is not actually simulated, so while the setting helps to achieve
    a more plausible object shapes at rest, it cannot create realistic fluid dynamics effects.
    It can also be used to give more weight to a soft body like object with heavy and
    sufficiently flexible filling, even if it is not a fluid by itself.

    The volume of the object is not preserved. If that is desired it should be used
    together with *Pressure Scale*. *Fluid density* times *object size* times 50
    is a good start value for *Scale* to make sure that no more than 10% volume change
    if the object does not experience higher acceleration than standard gravity.

Vertex Group
:   Cloth pressure can be controlled via a [Vertex Group](../../../modeling/meshes/properties/vertex_groups/index.xhtml)
    to specify which the portions of the mesh to apply pressure.
    Zero weight means no pressure while a weight of one means full pressure.

    Note, faces with a vertex that has zero weight will be excluded from the *Target Volume* calculation.
user: Provide the full official documentation entry for X-Ray, preserving all code examples.

assistant: The [X-Ray](../../../editors/3dview/display/shading.html#bpy-types-view3dshading-show-xray) setting is not just for shading, it impacts selection too.
When enabled, selection isn’t occluded by the objects geometry (as if the object was solid).

|  |  |
| --- | --- |
| <../../../_images/modeling_meshes_selecting_introduction_limit-selection-to-visible-off.png>   X-ray enabled. | <../../../_images/modeling_meshes_selecting_introduction_limit-selection-to-visible-on.png>   X-ray disabled. |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input. If no image is selected, an image filled with the selected color is used.
    You can use and crop this image in combination with another background image.

X
:   The X position of the lower left corner of the crop region.

Y
:   The Y position of the lower left corner of the crop region.

Width
:   The width of the crop region.

Height
:   The height of the crop region.

Alpha Crop
:   Sets the areas outside of the crop region to be transparent instead of actually cropping the size of the image.
user: Explain Simulation Stability in complete detail according to the official Blender documentation.

assistant: The simplest way of improving simulation stability is to increase the steps per second.
However, care has to be taken since making too many steps can cause problems and
make the simulation even less stable
(if you need more than 1000 steps, you should look at other ways to improve stability).

Increasing the number of solver iterations helps making constraints stronger and
also improves object stacking stability.

It is best to avoid small objects, as they are currently unstable.
Ideally, objects should be at least 20 cm in diameter.
If it is still necessary, setting the collision margin to 0,
while generally not recommended, can help making small object behave more naturally.

When objects are small and/or move very fast, they can pass through each other.
Besides what is mentioned above it’s also good to avoid using mesh shapes in this case.
Mesh shapes consist of individual triangles and therefore do not
really have any thickness, so objects can pass through more easily.
You can give them some thickness by increasing the collision margin.
user: Describe Marble from the Blender manual or Python API, including usage steps and snippets.

assistant: # Marble

The marble texture is used to generate marble, fire, or noise with a structure.
Bands are generated based on the sine, saw, or triangular formula and noise turbulence.

[image reference removed]

Marble Texture panels.
user: What is Locks and how is it used in Blender Python scripting?

assistant: Vertex groups can be locked to prevent undesired edits to a particular vertex group.

Lock All
:   Locks all vertex groups.

Lock Selected
:   Locks selected vertex groups.

Lock Unselected
:   Locks unselected vertex groups.

Lock Only Selected
:   Lock selected and unlock selected vertex groups.

Lock Only Unselected
:   Unlock selected and lock unselected vertex groups.

Unlock All
:   Unlocks all vertex groups.

Unlock Selected
:   Unlocks selected vertex groups.

Unlock Unselected
:   Unlocks Unselected vertex groups.

Invert Locks
:   Inverts the locks on all vertex groups.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: Closures define reusable logic that can be injected into another node tree. They are commonly used in procedural systems
where part of the behavior should remain user-defined.

Typical use cases include:

- Defining a custom scattering rule for a terrain generator.
- Describing how to distribute or modify instances procedurally.
- Providing adjustable mappings, field evaluations, or transformation logic.

### Using External Values

Closures can *capture* values from outside their zone. A captured value is stored as part of the closure definition and
remains available even when the closure is evaluated in a different context.

Captured values make it possible to preserve external parameters—such as scale, density, or color—without creating
explicit input sockets. This makes closures cleaner and easier to reuse in different node trees.

[image reference removed]

Capturing an external input value inside a closure.

### Example

1. In a terrain generator node group, replace the tree distribution logic with an
   [Evaluate Closure](evaluate_closure.xhtml) node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, create a *Closure Zone* and connect it to that input.
4. Inside the closure zone, define the desired tree placement logic.

When the generator evaluates the closure, the custom distribution defined in the zone is executed instead of the
default behavior.

[image reference removed]

A *Closure Zone* defining a custom distribution pattern for tree scattering.
user: Show practical ways to work with Blend-Files Previews in a Blender add-on or script – include code.

assistant: # Blend-Files Previews

A blend-file can store previews, both for itself, and for some of its [data-blocks](../data_blocks.html).
You can disable writing any previews when saving a blend-file using the *Save Preview Images* setting
from the [Save & Load](../../editors/preferences/save_load.html#prefs-save-load) section of the Preferences.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Value
:   The data retrieved and interpolated from the *Mesh* geometry, mapped based on the node’s settings and inputs.

Is Valid
:   Whether the node could find a single face to sample at the UV coordinate.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: X/Y
:   The marker’s X and Y location.

Speed
:   The velocity of the marker, measured in pixels per frame.
    This could be used to fake effects like motion blur by connecting it to the Vector Blur Node.
user: Provide the full official documentation entry for NodeCombineBundleItems(bpy_struct), preserving all code examples.

assistant: # NodeCombineBundleItems(bpy_struct)

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

*class* bpy.types.NodeCombineBundleItems(*bpy_struct*)
:   Collection of combine bundle items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_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)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`NodeCombineBundleItem`](bpy.types.NodeCombineBundleItem.html#bpy.types.NodeCombineBundleItem "bpy.types.NodeCombineBundleItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

assistant: ### General

### Unique

Magnify
:   Pulled geometry tends to lose volume along the stroke.
    With *Magnify* value greater than 0.5 this is prevented.
    More info at [Pinch/Magnify](../../brush/brush_settings.html#bpy-types-brush-crease-pinch-factor)

Rake
:   Rotates geometry along the direction of the stroke.

Deformation
:   Deformation type that is used by the brush.

    Radius Falloff:
    :   Applies the brush falloff to the tip of the brush.

    Elastic:
    :   Modifies the entire mesh using an [Elastic](../../../glossary/index.html#term-Elastic) deformation.
        More info in the [Elastic Deform](elastic_deform.html) brush.
user: Provide the full official documentation entry for Bpy.Types.Themecommonanim, preserving all code examples.

assistant: CommonAnim.keyframe_moving_hold_selected ThemeCommonAnim.keyframe_selected ThemeCommonAnim.long_key ThemeCommonAnim.long_key_selected ThemeCommonAnim.playhead ThemeCommonAnim.preview_range ThemeCommonAnim.scene_strip_range ThemeCommonAnim.bl_rna_get_subclass() ThemeCommonAnim.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Provide the full official documentation entry for Accessibility, preserving all code examples.

assistant: Reduce Motion
:   Avoids interface animations and motion effects.
    This option helps reduce visual distractions and can improve comfort for
    users sensitive to motion or those who prefer a more static interface.
user: Explain AOV Output Node in complete detail according to the official Blender documentation.

assistant: # AOV Output Node

[image reference removed]

Shader AOVs (Arbitrary Output Variables) provide custom render passes for arbitrary shader node components.
As an artist this can be a good way to debug or tweak very fine details of a scene in post-processing.
To use shader AOVs create the pass in the [Shader AOV](../../layers/passes.html#bpy-types-aov) panel
then reference that pass with the *AOV Output* shading node.
Shader AOVs can be added or removed in the *Shader AOV* panel.
user: Give a detailed overview of Dependency graph: Evaluated ID example: syntax, arguments, return values, common patterns.

assistant: This example demonstrates access to the evaluated ID (such as object, material, etc.) state from
an original ID.
This is needed every time one needs to access state with animation, constraints, and modifiers
taken into account.

```
import bpy

class OBJECT_OT_evaluated_example(bpy.types.Operator):
    """Access evaluated object state and do something with it"""
    bl_label = "DEG Access Evaluated Object"
    bl_idname = "object.evaluated_example"

    def execute(self, context):
        # This is an original object. Its data does not have any modifiers applied.
        obj = context.object
        if obj is None or obj.type != 'MESH':
            self.report({'INFO'}, "No active mesh object to get info from")
            return {'CANCELLED'}
        # Evaluated object exists within a specific dependency graph.
        # We will request evaluated object from the dependency graph which corresponds to the
        # current scene and view layer.
        #
        # NOTE: This call ensure the dependency graph is fully evaluated. This might be expensive
        # if changes were made to the scene, but is needed to ensure no dangling or incorrect
        # pointers are exposed.
        depsgraph = context.evaluated_depsgraph_get()
        # Actually request evaluated object.
        #
        # This object has animation and drivers applied on it, together with constraints and
        # modifiers.
        #
        # For mesh objects the object.data will be a mesh with all modifiers applied.
        # This means that in access to vertices or faces after modifier stack happens via fields of
        # object_eval.object.
        #
        # For other types of objects the object_eval.data does not have modifiers applied on it,
        # but has animation applied.
        #
        # NOTE: All ID types have `evaluated_get()`, including materials, node trees, worlds.
        object_eval = obj.evaluated_get(depsgraph)
        mesh_eval = object_eval.data
        self.report({'INFO'}, f"Number of evaluated vertices: {len(mesh_eval.vertices)}")
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_evaluated_example)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_evaluated_example)

if __name__ == "__main__":
    register()
```
user: How do I use Curve in Blender? Include parameters, examples, warnings and best practices.

assistant: Converts the selected mesh or text object into a curve object.

- **For mesh objects**: Only loose edges (edges not part of any faces) will be included in the conversion.
- **For text objects**: The text is converted into curve outlines, preserving its shape.

The resulting curve will be [Poly Curve](../../../modeling/curves/structure.xhtml#curve-poly) by default.
To create smooth segments, convert the curve to a [Bézier Curve](../../../modeling/curves/structure.xhtml#curve-bezier)
using [Set Spline Type](../../../modeling/curves/editing/curve.xhtml#bpy-ops-curve-spline-type-set).
user: Provide the full official documentation entry for Draw Face Sets, preserving all code examples.

assistant: # Draw Face Sets

Draw new or extend existing [Face Sets](../editing/face_sets.html#sculpting-editing-facesets) with each stroke.

Holding `Ctrl` will continue drawing the same face set as the one under the cursor.
Holding `Shift` will relax or smooth the edges of the face sets
by modifying the underlying topology so edges flow along the perimeter of the face sets.
This will remove the jagged lines visible after drawing or creating a face set.
user: Describe Technical Details and Hints from the Blender manual or Python API, including usage steps and snippets.

assistant: The relationship of the above values is described here:

[image reference removed]

Wave front characteristics.

To obtain a nice wave effect similar to sea waves and close to a sinusoidal wave,
make the distance between following ripples and the ripple width equal. That is,
the *Narrowness* value must be equal to `2 / Width`.
E.g. for *Width* to be 1, set *Narrow* to 2.
user: Describe D from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [**Data User**](glossary/index.html#term-Data-User) - [**Data-Block**](glossary/index.html#term-Data-Block) - [**Depth of Field**](glossary/index.html#term-Depth-of-Field) - [**Dielectric Material**](glossary/index.html#term-Dielectric-Material) - [**Diffuse Light**](glossary/index.html#term-Diffuse-Light) - [**Directional Light**](glossary/index.html#term-Directional-Light) | - [**Displacement Mapping**](glossary/index.html#term-Displacement-Mapping) - [**Display Referenced**](glossary/index.html#term-Display-Referenced) - [**DOF**](glossary/index.html#term-DOF) - [**Dots Per Inch**](glossary/index.html#term-Dots-Per-Inch) - [**Double Buffer**](glossary/index.html#term-Double-Buffer) - [**DPI**](glossary/index.html#term-DPI) |
user: Explain Combine Spherical Node in complete detail according to the official Blender documentation.

assistant: # Combine Spherical Node

[image reference removed]

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

Spherical coordinates represent a point in 3D space by its distance from the origin,
horizontal rotation, and vertical inclination, which can be useful for constructing
radial or rotational patterns and generating coordinates on a sphere.
user: How do I use Set Curve Normal Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Curve Normal Node

[image reference removed]

The *Set Curve Normal* controls the method used to calculate curve normals for every curve.

The node doesn’t set the normals directly, those are calculated later as necessary.
Combined with the [tilt](../read/curve_tilt.html) attribute value
at each control point, this will define the final normals accessible with the
[Normal Node](../../geometry/read/normal.html).

Internally this node adjusts the values of the `normal_mode` attribute on each curve.
user: How do I use ArmatureConstraintTargets(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ArmatureConstraintTargets(bpy_struct)

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

*class* bpy.types.ArmatureConstraintTargets(*bpy_struct*)
:   Collection of target bones and weights

    new()
    :   Add a new target to the constraint

        Returns:
        :   New target bone

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

    remove(*target*)
    :   Delete target from the constraint

        Parameters:
        :   **target** ([`ConstraintTargetBone`](bpy.types.ConstraintTargetBone.html#bpy.types.ConstraintTargetBone "bpy.types.ConstraintTargetBone"), (never None)) – Target to remove

    clear()
    :   Delete all targets from object

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

assistant: Unit System
:   The unit system to use for user interface controls.

    None:
    :   Use units that have with no relation to the real world,
        practically this is the same as *Metric* just without unit names.

    Metric:
    :   Use the metric unit system in this scene.

    Imperial:
    :   Use the imperial unit system in this scene.

Unit Scale
:   Scale factor to use when converting between internal units and values displayed in the user interface.
    This can be changed when modeling at microscopic or astronomical scales.

Separate Units
:   When using *Metric* or *Imperial*, display properties as multiple values.
    For example, `2.285m` will become `2m 28.5cm`.

Rotation
:   Unit to use for displaying/editing rotation values.

    Degrees:
    :   Use degrees for angles in the user interface.

    Radians:
    :   Use radians for angles in the user interface.

Length
:   Unit that will be used to display length values.

    Adaptive:
    :   The unit used for a specific value depends on the magnitude of the value.
        For example, some values might be displayed as `23cm` while others are
        displayed as `10km`.

    Meters/Centimeters/Feet:
    :   A fixed unit that will be used for all lengths in the user interface.

Mass
:   See *Length*.

Time
:   See *Length*.

Temperature
:   See *Length*.

Imperial Length Units

| Full Name | Short Name(s) | Scale of a Meter |
| --- | --- | --- |
| thou | `mil` | 0.0000254 |
| inch | `"`, `in` | 0.0254 |
| foot, feet | `'`, `ft` | 0.3048 |
| yard | `yd` | 0.9144 |
| chain | `ch` | 20.1168 |
| furlong | `fur` | 201.168 |
| mile | `mi`, `m` | 1609.344 |

Metric Length Units

| Full Name | Short Name(s) | Scale of a Meter |
| --- | --- | --- |
| micrometer | `um` | 0.000001 |
| millimeter | `mm` | 0.001 |
| centimeter | `cm` | 0.01 |
| decimeter | `dm` | 0.1 |
| meter | `m` | 1.0 |
| dekameter | `dam` | 10.0 |
| hectometer | `hm` | 100.0 |
| kilometer | `km` | 1000.0 |
user: Give a detailed overview of ImagePreview(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ImagePreview(bpy_struct)

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

*class* bpy.types.ImagePreview(*bpy_struct*)
:   Preview image and icon

    icon_id
    :   Unique integer identifying this preview as an icon (zero means invalid)

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    icon_pixels
    :   Icon pixels, as bytes (always 32-bit RGBA)

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

    icon_pixels_float
    :   Icon pixels components, as floats (RGBA concatenated values)

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

    icon_size
    :   Width and height in pixels

        Type:
        :   int array of 2 items in [-inf, inf], default (0, 0)

    image_pixels
    :   Image pixels, as bytes (always 32-bit RGBA)

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

    image_pixels_float
    :   Image pixels components, as floats (RGBA concatenated values)

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

    image_size
    :   Width and height in pixels

        Type:
        :   int array of 2 items in [-inf, inf], default (0, 0)

    is_icon_custom
    :   True if this preview icon has been modified by py script, and is no more auto-generated by Blender

        Type:
        :   boolean, default False

    is_image_custom
    :   True if this preview image has been modified by py script, and is no more auto-generated by Blender

        Type:
        :   boolean, default False

    reload()
    :   Reload the preview from its source path

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Attribute Type Items

FLOAT:
:   Float.

    Floating-point value.

INT:
:   Integer.

    32-bit integer.

BOOLEAN:
:   Boolean.

    True or false.

FLOAT_VECTOR:
:   Vector.

    3D vector with floating-point values.

FLOAT_COLOR:
:   Color.

    RGBA color with 32-bit floating-point values.

QUATERNION:
:   Quaternion.

    Floating point quaternion rotation.

FLOAT4X4:
:   4x4 Matrix.

    Floating point matrix.

STRING:
:   String.

    Text string.

INT8:
:   8-Bit Integer.

    Smaller integer with a range from -128 to 127.

INT16_2D:
:   2D 16-Bit Integer Vector.

    16-bit signed integer vector.

INT32_2D:
:   2D Integer Vector.

    32-bit signed integer vector.

FLOAT2:
:   2D Vector.

    2D vector with floating-point values.

BYTE_COLOR:
:   Byte Color.

    RGBA color with 8-bit positive integer values.
user: Show practical ways to work with Control Points in a Blender add-on or script – include code.

assistant: Like all curves in Blender, the curve in this widget is defined using *control points*.

Add
:   Click `LMB` anywhere on the curve where there is not already a control point.

Move
:   Drag the point with `LMB`.

Remove
:   Select the point and click the  button at the bottom right.
    Alternatively, press `X`.
user: Give a detailed overview of Visibility: syntax, arguments, return values, common patterns.

assistant: Use Light
:   Enables the Grease Pencil object to be affected by lights.

    This property affect the whole object, for more control with lights you can enable or disable
    the use of lights by layers. See [Layers](layers.xhtml) for more information.

    [image reference removed]

    Lights disabled (left) and enabled (right).
user: Explain Footer in complete detail according to the official Blender documentation.

assistant: Some editors show a bar (on top/bottom of the editor area)
that displays information about for example the active tool or operator.

In animation editors, the footer contains controls and options related to playback, keying, auto keyframing, and
transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.
user: What is MotionPathVert(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MotionPathVert(bpy_struct)

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

*class* bpy.types.MotionPathVert(*bpy_struct*)
:   Cached location on path

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

    select
    :   Path point is selected for editing

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

assistant: # Viewport Display

Thickness
:   Factor that scales the thickness of the grid that is currently being displayed.

Interpolation
:   Interpolation method to use for the visualization of the fluid grid.

    Linear:
    :   Linear interpolation between voxels. Gives good smoothness and speed.

    Cubic:
    :   Cubic interpolation between voxels. Gives smoothed high quality interpolation, but is slower.

    Closest:
    :   No interpolation between voxels. Gives raw voxels.

Slice per Voxel
:   Determines how many slices per voxel should be generated.
user: Show practical ways to work with Playhead in a Blender add-on or script – include code.

assistant: [image reference removed]

Playhead.

The *Playhead* is the blue vertical line showing the current frame number.

It can be moved to a new position by clicking or
dragging `LMB` in the scrubbing area at the top or by
click and drag `Shift`-`RMB` anywhere in the timeline.

While dragging it can snap to elements of the editor in which it is dragged.
- Seconds
- Frames
- Markers
- Strips
- Keys

It is only possible to snap to elements that are visible in the editor in which the playhead is dragged.
For example having “Strips” enabled but dragging in the Graph Editor will do nothing.
Snapping can be toggled during scrubbing by holding down `Ctrl`.

Snapping to seconds or frames can have a custom increment for example snapping to every third frame.
This is always relative to the first frame of the scene and ignores the preview range.
In contrast to the other snapping options, seconds and frames will always snap to the closest position,
regardless of the snap distance set. When mixing options, the system will first try to snap to
elements that are snapped by distance. Only if no element is close enough will it snap to seconds or frames.

You can also move it in single-frame increments by pressing `Left` or `Right` or `Alt`-`Wheel`.
To jump to the beginning or end frame (of the ends of the preview range if that is active)
press `Shift`-`Left` or `Shift`-`Right`.

### Snapping

Playhead snapping helps you position the playhead precisely when scrubbing the timeline
by snapping it to specific elements like frames, markers, or keyframes.

Use Snapping
:   Enables or disables snapping behavior when moving the playhead.

Snap Distance
:   The maximum distance (in pixels) the playhead can be from a target before snapping to it.

Snap Target
:   Specifies which elements the playhead can snap to:

    Frames:
    :   Snap to frame intervals.

    Seconds:
    :   Snap to second intervals.

    Markers:
    :   Snap to timeline markers.

    Keyframes:
    :   Snap to animation keyframes.

    Strips:
    :   Snap to the start and end points of strips (e.g. in the Video Sequencer).

Frame Step Frames
:   The interval in frames between each snap point when using the *Frames* target.

Second Step Seconds
:   The interval in seconds between each snap point when using the *Seconds* target.
user: Show practical ways to work with In Object Mode in a Blender add-on or script – include code.

assistant: When in Object Mode,
rotation and scaling happen around the origin of the active object,
which is the element with a lighter outline than the others.

The effect of the pivot point is shown in the image below, where the active object (the cube)
remains in the same location while the others move.

[image reference removed]

Starting point, rotation, and scaling.
user: Provide the full official documentation entry for XrNavigation(bpy_struct), preserving all code examples.

assistant: # XrNavigation(bpy_struct)

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

*class* bpy.types.XrNavigation(*bpy_struct*)
:   VR navigation settings

    invert_rotation
    :   Reverses the direction of rotation input

        Type:
        :   boolean, default False

    snap_turn
    :   Instantly rotates the camera by a fixed angle instead of smoothly turning

        Type:
        :   boolean, default True

    turn_amount
    :   Amount in degrees per turn when using snap turn

        Type:
        :   float in [0, 6.28319], default 0.523599

    turn_speed
    :   Turn speed in degrees per second

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

    vignette_intensity
    :   Intensity of vignette that appears when moving

        Type:
        :   float in [0, 100], default 60.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: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Selecting a Brush

In the Tool Settings select the brush to use with the tool.
The Erase tool uses [Erase Brush](../brushes/index.html#grease-pencil-draw-brushes-erase) types (soft, point and stroke).

### Dissolve Erasing

- Select an erase brush of type Soft/Hard.
- Adjust brush settings.
- Click and hold `LMB` or use the `Pen` tip to delete strokes on the viewport.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_erase_soft-01.png>   Original drawing. | <../../../../_images/grease-pencil_modes_draw_tools_erase_soft-02.png>   The eraser affect the transparency of the strokes. | <../../../../_images/grease-pencil_modes_draw_tools_erase_soft-03.png>   Final result. |

### Point Erasing

- Select an erase brush of type Point.
- Adjust brush settings.
- Click and hold `LMB` or use the `Pen` tip to delete strokes on the viewport.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_erase_point-01.png>   Original drawing. | <../../../../_images/grease-pencil_modes_draw_tools_erase_point-02.png>   The eraser delete one point at a time. | <../../../../_images/grease-pencil_modes_draw_tools_erase_point-03.png>   Final result. |

### Stroke Erasing

- Select an erase brush of type Stroke.
- Adjust brush settings.
- Click and hold `LMB` or use the `Pen` tip to delete strokes on the viewport.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_erase_stroke-01.png>   Original drawing. | <../../../../_images/grease-pencil_modes_draw_tools_erase_stroke-02.png>   The eraser delete one stroke at a time. | <../../../../_images/grease-pencil_modes_draw_tools_erase_stroke-03.png>   Final result. |
user: Explain Saving Catalogs in complete detail according to the official Blender documentation.

assistant: Saving catalogs makes any edits to any catalogs permanent by writing the current set up to the asset library.
Catalogs can be saved in the [Asset Browser](../../editors/asset_browser.xhtml)
through Header ‣ Catalog ‣ Save Asset Catalog.
Once the catalog is created you can double `LMB` on it’s name
Catalogs can also be saved in the *Source List* region of the editor
by clicking the save icon found at the top of the tree view.
user: Give a detailed overview of Locks: syntax, arguments, return values, common patterns.

assistant: Vertex groups can be locked to prevent undesired edits to a particular vertex group.

Lock All
:   Locks all vertex groups.

Lock Selected
:   Locks selected vertex groups.

Lock Unselected
:   Locks unselected vertex groups.

Lock Only Selected
:   Lock selected and unlock selected vertex groups.

Lock Only Unselected
:   Unlock selected and lock unselected vertex groups.

Unlock All
:   Unlocks all vertex groups.

Unlock Selected
:   Unlocks selected vertex groups.

Unlock Unselected
:   Unlocks Unselected vertex groups.

Invert Locks
:   Inverts the locks on all vertex groups.
user: Show practical ways to work with FunctionNodeQuaternionToRotation(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeQuaternionToRotation(FunctionNode)

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

*class* bpy.types.FunctionNodeQuaternionToRotation(*FunctionNode*)
:   Build a rotation from quaternion components

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

assistant: The collision margin is used to improve the performance and stability of rigid bodies.
Depending on the shape, it behaves differently: some shapes embed it,
while others have a visible gap around them.

The margin is *embedded* for these shapes:

- Sphere
- Box
- Capsule
- Cylinder
- Convex Hull: Only allows for uniform scale when embedded.

The margin is *not embedded* for these shapes:

- Cone
- Active Triangle Mesh
- Passive Triangle Mesh: Can be set to 0 most of the time.

Margin
:   Threshold of distance near the surface where collisions are still considered (best results when nonzero).
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: # Options

Auto Normalize
:   Ensures that all deforming vertex groups add up to one while painting.
    When this option is turned off, then all weights of a point can have any value between 0 and 1.
    However, when vertex groups are used as deform groups for character animation
    then Blender always interprets the weight values relative to each other.
    That is, Blender always does a normalization over all deform bones.
    Hence in practice it is not necessary to maintain a strict normalization and
    further normalizing weights should not affect animation at all.

    This option works most intuitively when used to maintain normalization while
    painting on top of weights that are already normalized with another tool.
user: Provide the full official documentation entry for ShaderNodeLightFalloff(ShaderNode), preserving all code examples.

assistant: # ShaderNodeLightFalloff(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.ShaderNodeLightFalloff(*ShaderNode*)
:   Manipulate how light intensity decreases over distance. Typically used for non-physically-based effects; in reality light always falls off quadratically

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleAlphaModifier.name`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier.name "bpy.types.LineStyleAlphaModifier.name") |
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`NodeTreeInterface.active`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.active "bpy.types.NodeTreeInterface.active") - [`NodeTreeInterface.copy`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.copy "bpy.types.NodeTreeInterface.copy") - [`NodeTreeInterface.copy`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.copy "bpy.types.NodeTreeInterface.copy") - [`NodeTreeInterface.items_tree`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.items_tree "bpy.types.NodeTreeInterface.items_tree") | - [`NodeTreeInterface.move`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.move "bpy.types.NodeTreeInterface.move") - [`NodeTreeInterface.move_to_parent`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.move_to_parent "bpy.types.NodeTreeInterface.move_to_parent") - [`NodeTreeInterface.remove`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.remove "bpy.types.NodeTreeInterface.remove") - [`NodeTreeInterfacePanel.interface_items`](bpy.types.NodeTreeInterfacePanel.html#bpy.types.NodeTreeInterfacePanel.interface_items "bpy.types.NodeTreeInterfacePanel.interface_items") |