PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is MovieTrackingObject(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MovieTrackingObject(bpy_struct)

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

*class* bpy.types.MovieTrackingObject(*bpy_struct*)
:   Match-moving object tracking and reconstruction data

    is_camera
    :   Object is used for camera tracking

        Type:
        :   boolean, default False, (readonly)

    keyframe_a
    :   First keyframe used for reconstruction initialization

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

    keyframe_b
    :   Second keyframe used for reconstruction initialization

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

    name
    :   Unique name of object

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

    plane_tracks
    :   Collection of plane tracks in this tracking data object

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

    reconstruction
    :   Type:
        :   [`MovieTrackingReconstruction`](bpy.types.MovieTrackingReconstruction.html#bpy.types.MovieTrackingReconstruction "bpy.types.MovieTrackingReconstruction"), (readonly)

    scale
    :   Scale of object solution in camera space

        Type:
        :   float in [0.0001, 10000], default 1.0

    tracks
    :   Collection of tracks in this tracking data object

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

The Warp modifier.

Object From
:   The object defining the origin transformation of the warp.

Object To
:   The object defining the destination transformation of the warp.

Preserve Volume
:   Enables volume preservation when rotating one of the transforms.

Strength
:   Sets how strong the effect is.

Vertex Group
:   The name of a vertex group which is used to control the influence of the modifier.
    If left empty, the modifier affects all vertices equally.

    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.

### Falloff

Falloff Type
:   Sets the way the strength of the warp change as it goes from the center of the transform to the *Radius* value.
    See [Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml)
    for descriptions of the falloff types.

Radius
:   Sets the distance from the transforms that can be warped by the transform handles.

### Texture

Texture
:   You can finely control which vertices are affected by the warp,
    and to what extent, using a texture.

See [common masking options](../common_options.xhtml#modifiers-common-options-masking) for a complete reference.
user: Explain GeometryNodeSetInstanceTransform(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSetInstanceTransform(GeometryNode)

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

*class* bpy.types.GeometryNodeSetInstanceTransform(*GeometryNode*)
:   Set the transformation matrix of every instance

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Scatter on Surface Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Scatter on Surface Node

[image reference removed]

The *Scatter on Surface* node distributes points or instances across the surface of a mesh.
It provides flexible control over how elements are placed using density, randomization,
and Poisson disk sampling.
This node is useful for procedural scattering of objects such as grass, rocks, or debris
on terrain or any other surface.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`EffectStrip.transform`](bpy.types.EffectStrip.html#bpy.types.EffectStrip.transform "bpy.types.EffectStrip.transform") - [`ImageStrip.transform`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.transform "bpy.types.ImageStrip.transform") - [`MaskStrip.transform`](bpy.types.MaskStrip.html#bpy.types.MaskStrip.transform "bpy.types.MaskStrip.transform") - [`MetaStrip.transform`](bpy.types.MetaStrip.html#bpy.types.MetaStrip.transform "bpy.types.MetaStrip.transform") | - [`MovieClipStrip.transform`](bpy.types.MovieClipStrip.html#bpy.types.MovieClipStrip.transform "bpy.types.MovieClipStrip.transform") - [`MovieStrip.transform`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.transform "bpy.types.MovieStrip.transform") - [`SceneStrip.transform`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.transform "bpy.types.SceneStrip.transform") |
user: Describe Separate Color Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Separate Color Node

[image reference removed]

The *Separate Color Node* splits an image into its composite color channels.
The node can output multiple [Color Models](../../../glossary/index.xhtml#term-Color-Model) depending on the Mode property.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: Colorize Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_colorize_grayscale.png   Mode: Grayscale. | ../../_images/grease-pencil_visual-effects_colorize_sepia.png   Mode: Sepia. | ../../_images/grease-pencil_visual-effects_colorize_duotone.png   Mode: Duotone. | ../../_images/grease-pencil_visual-effects_colorize_transparent.png   Mode: Transparent. |
user: Give a detailed overview of LatticeModifier(Modifier): syntax, arguments, return values, common patterns.

assistant: # LatticeModifier(Modifier)

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

*class* bpy.types.LatticeModifier(*Modifier*)
:   Lattice deformation modifier

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    object
    :   Lattice object to deform with

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

    strength
    :   Strength of modifier effect

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

    vertex_group
    :   Name of Vertex Group which determines influence of modifier per point

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Object.shader_effects`](bpy.types.Object.html#bpy.types.Object.shader_effects "bpy.types.Object.shader_effects") - [`ObjectShaderFx.new`](bpy.types.ObjectShaderFx.html#bpy.types.ObjectShaderFx.new "bpy.types.ObjectShaderFx.new") | - [`ObjectShaderFx.remove`](bpy.types.ObjectShaderFx.html#bpy.types.ObjectShaderFx.remove "bpy.types.ObjectShaderFx.remove") |
user: Provide the full official documentation entry for Annotations, preserving all code examples.

assistant: # Annotations

The annotation tool is available in multiple editors.
It can be used to add notes to e.g. 3D objects or node setups.
The arrow in the screenshot below is an annotation.

[image reference removed]

Annotations tool in a node editor.
user: Provide the full official documentation entry for Navigating in Paint Modes, preserving all code examples.

assistant: # Navigating in Paint Modes

There are different preferences for navigating the 3D Viewport in Blender.
For painting and sculpting specific workflows it is recommended to use any of the following methods.

Center View to Mouse `Alt` `MMB`
:   Center the View on the surface directly under the mouse position.
    This way the rotation point of the viewport can be manually changed to any point you wish to orbit around.

Center on Last Stroke `NumpadPeriod`
:   Center the View on the average position of the last stroke.

Various preferences can also make navigation more convenient.
These can be found in the “Navigation” tab of the preferences.

Orbit Method = Trackball
:   Tumble the view based on the mouse position in your 3D Viewport while rotating.
    This makes it very easy to tilt the viewport freely,
    instead of having the Z axis of the viewport locked.

[Zoom to Mouse Position](../editors/preferences/navigation.xhtml#bpy-types-preferencesinput-use-zoom-to-mouse)
:   Use the mouse position to zoom towards and rotate around the surface that is pointed at.
    This can be an alternative to the repeated manual use of the Center View to Mouse operator.

    The disadvantage is that this navigation preference can lead to accidental navigation
    around backfacing geometry or very distant geometry.
user: How do I use Bpy.Types.Shadernodetexnoise in Blender? Include parameters, examples, warnings and best practices.

assistant: red_node_type() ShaderNodeTexNoise.input_template() ShaderNodeTexNoise.output_template() ShaderNodeTexNoise.bl_rna_get_subclass() ShaderNodeTexNoise.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Describe Make Parent without Inverse from the Blender manual or Python API, including usage steps and snippets.

assistant: This sets the parent, and then resets the *Parent Inverse* matrix and the object’s local location.
As a result, the object will move to the location of the parent, but keep its rotation and scale.

Keep Transform
:   The object’s current world transform (so its absolute location, rotation and scale in the world) is computed.
    The new parent is set, and then the local transform values are set in such a way that after setting
    the new parent the object is still at its previous world transform.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Target
:   Render engine the input shader is used for.
    By default, the shader is shared between Cycles and EEVEE –
    with multiple output nodes, a specialized shader setup can be created for each.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`GreasePencilTreeNode.next_node`](#bpy.types.GreasePencilTreeNode.next_node "bpy.types.GreasePencilTreeNode.next_node") | - [`GreasePencilTreeNode.prev_node`](#bpy.types.GreasePencilTreeNode.prev_node "bpy.types.GreasePencilTreeNode.prev_node") |
user: Explain Boid Brain in complete detail according to the official Blender documentation.

assistant: The Boid Brain panel controls how the boids particles will react with each other.
The boids’ behavior is controlled by a list of rules.
Only a certain amount of information in the list can be evaluated.
If the memory capacity is exceeded, the remaining rules are ignored.

The rules are by default parsed from top-list to bottom-list
(thus giving explicit priorities),
and the order can be modified using the little arrows buttons on the right side.

Rule Evaluation
:   There are three ways to control how rules are evaluated:

    Average
    :   All rules are averaged.

    Random
    :   A random rule is selected for each boid.

    Fuzzy
    :   Uses fuzzy logic to evaluate rules. Rules are gone through top to bottom.
        Only the first rule that affect above the *Rule Fuzziness* threshold is evaluated.
        The value should be considered how hard the boid will try to respect a given rule
        (a value of 1 means the Boid will always stick to it, a value of 0 means it will never).
        If the boid meets more than one conflicting condition at the same time,
        it will try to fulfill all the rules according to the respective weight of each.

In Air
:   The current rule affects boids while they are flying.

On Land
:   The current rule affects boids while they are not flying.

### Goal Rule

Seek goal.

Object
:   Specifies the goal object. If not specified, Boid force fields with negative Strength are used as goals.

Predict
:   Predict target’s movements.

### Avoid Rule

Avoid “predators”.

Object
:   Specifies the object to avoid.
    If not specified, Boid force fields with positive Strength are used as predators.

Predict
:   Predict target’s movements.

Fear Factor
:   Avoid object if danger from it is above this threshold.

### Avoid Collision Rule

Avoid objects with activated Deflection.

Boids
:   Avoid collision with other boids.

Deflectors
:   Avoid collision with deflector objects.

Look Ahead
:   Time to look ahead in seconds.

### Separate Rule

Boids move away from each other.

### Flock Rule

Copy movements of neighboring boids, but avoid each other.

### Follow Leader Rule

Follows a leader object instead of a boid.

Distance
:   Distance behind leader to follow.

Line
:   Follow the leader in a line.

    Queue Size
    :   How many boids that are allowed to follow in a line.

### Average Speed Rule

Maintain average velocity.

Speed
:   Percentage of maximum speed.

Wander
:   How fast velocity’s direction is randomized.

Level
:   How much velocity’s Z component is kept constant.

### Fight Rule

Move toward nearby boids.

Fight Distance
:   Attack boids at a maximum of this distance.

Flee Distance
:   Flee to this distance.
user: Describe Locking Bones from the Blender manual or Python API, including usage steps and snippets.

assistant: You can prevent a bone from being transformed in *Edit Mode* in several ways:

- All bones can be locked clicking on the *Lock* checkbox
  of their Transform panel in the *Bones* tab;
- Press `Shift`-`W` Toggle Bone Options ‣ Locked
- Select Armature ‣ Bone Settings ‣ Toggle a Setting.

*If the root of a locked bone is connected to the tip of an unlocked bone, it will not be locked*,
i.e. you will be able to move it to your liking.
This means that in a chain of connected bones, when you lock one bone,
you only really lock its tip. With unconnected bones, the locking is effective on both joints of the bone.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: # Usage

Drivers can be added to properties via their context menu, a shortcut, copy-pasted,
or by typing an expression directly into the property’s value.

After adding drivers, they are usually modified in the [Drivers editor](../../editors/drivers_editor.xhtml),
or via a simplified *Edit Driver* popover invoked from the property context menu.
user: Give a detailed overview of Auto-Masking: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Auto-Masking settings.

These properties automatically mask geometry based on stroke, layers and materials under the cursor.
It’s an quick alternative to frequent manual masking.
These masks are initialized on every new tool usage. They are also never visible as an overlay.

These properties can be accessed via a [Pie Menus](../../../interface/controls/buttons/menus.xhtml#bpy-types-uipiemenu) by pressing `Shift`-`Alt`-`A`.

All auto-masking modes can be combined, which makes the generated auto-mask more specific.
For example it’s possible to auto-mask strokes that use specific layer and material while excluding others.

Stroke
:   Only strokes that are under the cursor when you started the tool are affected.

Layer
:   Only strokes on the same layers that are under the cursor when you started the tool are affected.

Material
:   Only materials with the same material that are under the cursor when you started the tool are affected.

Active Layer
:   Only the strokes on the active layer are affected.

Active Material
:   Only the strokes with the active material are affected.
user: Give a detailed overview of Combine Cylindrical Node: syntax, arguments, return values, common patterns.

assistant: # Combine Cylindrical Node

[image reference removed]

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

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: Show practical ways to work with Trim in a Blender add-on or script – include code.

assistant: Trims selected stroke to first loop or intersection.

|  |  |
| --- | --- |
| <../../../_images/grease-pencil_modes_edit_stroke-menu_trim-1.png>   Original stroke. | <../../../_images/grease-pencil_modes_edit_stroke-menu_trim-2.png>   Result of trim operation. |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Points
:   Standard geometry input. The position of the points of this geometry affect the transforms of
    each instance output.

Selection
:   Whether to instance on each point. True values mean an instance will be generated on the point,
    false values mean the point will be skipped.

Instance
:   The geometry to instance on each selected point. This can contain real geometry, or multiple instances,
    which can be useful when combined with the *Pick Instance* option.

Pick Instances
:   If enabled, instead of adding the entire geometry from the *Instance* input on every point,
    choose an instance from the instance list of the geometry based on the *Instance Index* input.
    This option is intended to be used with the [Collection Info Node](../input/scene/collection_info.xhtml).

Instance Index
:   The selection of index for every selected point, only used when *Pick Instances* is true.
    By default the point [ID](../geometry/read/id.xhtml) is used,
    or the [index](../geometry/read/input_index.xhtml) if that doesn’t exist.
    Negative values or values that are too large are wrapped around to the other end of
    the instance list.

Rotation
:   The [Euler](../../../glossary/index.xhtml#term-Euler) rotation for every instance. This can use the rotation output of nodes like
    [Distribute Points on Faces](../point/distribute_points_on_faces.xhtml)
    and [Curve to Points](../curve/operations/curve_to_points.xhtml). An Euler rotation
    can also be created from a direction vector like the [normal](../geometry/read/normal.xhtml)
    with the [Align Rotation to Vector Node](../utilities/rotation/align_rotation_to_vector.xhtml).

Scale
:   The size of each generated instance.
user: Explain Set Attribute in complete detail according to the official Blender documentation.

assistant: Opens a pop-up window showing the name of the [active](../../glossary/index.xhtml#term-Active) [attribute](../../glossary/index.xhtml#term-Attribute)
as well as the value of that attribute for the selected points
From there, you assign a new value to a selected attribute across all selected points.

This tool is useful for uniformly setting attribute values such as size, color, or velocity across selected points.
user: How do I use bpy_prop_collection_idprop in Blender? Include parameters, examples, warnings and best practices.

assistant: # bpy_prop_collection_idprop

base classes — [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection")

*class* bpy.types.bpy_prop_collection_idprop
:   built-in class used for user defined collections.

    add()
    :   This is a function to add a new item to a collection.

        Returns:
        :   A newly created item.

        Return type:
        :   Any

    clear()
    :   This is a function to remove all items from a collection.

    move(*src_index*, *dst_index*)
    :   This is a function to move an item in a collection.

        Parameters:
        :   - **src_index** (*int*) – Source item index.
            - **dst_index** (*int*) – Destination item index.

    remove(*index*)
    :   This is a function to remove an item from a collection.

        Parameters:
        :   **index** (*int*) – Index of the item to be removed.
user: Show practical ways to work with Locking in a Blender add-on or script – include code.

assistant: [[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_editor-locked.png)

Locked vertex group.

If a vertex group is locked, its weights become uneditable, and the buttons for copying
and normalizing weights become disabled.
user: Give a detailed overview of Markup Style Guide: syntax, arguments, return values, common patterns.

assistant: # Markup Style Guide

This page covers conventions for writing Blender’s documentation using reStructuredText (RST) markup syntax.
Following these conventions ensures clarity, consistency, and ease of maintenance.
user: Show practical ways to work with Relative To Pixel Node in a Blender add-on or script – include code.

assistant: # Relative To Pixel Node

[image reference removed]

The *Relative To Pixel* node converts values that are relative to the image size into values in pixel units.
This is useful when working with screen-space operations that require absolute pixel values,
such as blurring or positioning effects in the compositor.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Points
:   The input points that define the centers of the generated SDF regions.

Radius
:   The radius of influence for each point, defining how far the signed
    distance extends from the point center. Each point is treated as a sphere
    with this radius.

Voxel Size
:   The size of each voxel in object space units.
    Smaller voxel sizes yield higher-resolution fields that better capture
    fine detail, at the cost of increased memory and processing time.
user: Give a detailed overview of GeometryNodeFieldToGridItems(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeFieldToGridItems(bpy_struct)

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

*class* bpy.types.GeometryNodeFieldToGridItems(*bpy_struct*)
:   Collection of field to grid 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:
        :   [`GeometryNodeFieldToGridItem`](bpy.types.GeometryNodeFieldToGridItem.html#bpy.types.GeometryNodeFieldToGridItem "bpy.types.GeometryNodeFieldToGridItem")

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`GeometryNodeFieldToGridItem`](bpy.types.GeometryNodeFieldToGridItem.html#bpy.types.GeometryNodeFieldToGridItem "bpy.types.GeometryNodeFieldToGridItem"), (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: Provide the full official documentation entry for Raytracing, preserving all code examples.

assistant: # Raytracing

The ray-tracing pipeline goal is to increase the accuracy of surface indirect lighting.
This is done by generating ray from each BSDF
and finding their intersection with the scene individually.

When disabled, it is replaced by a faster pipeline that uses pre-filtered light-probes.
This fallback mode offers a more visually stable and optimized alternative when visual
fidelity is not the primary goal.

Method
:   Determine the tracing method used to find scene-ray intersections and indirect lighting.

    Light Probe:
    :   Use light-probe spheres and planes to find scene intersection.
        This option has the lowest tracing cost but relies on manually placed light-probes.

    Screen-Trace:
    :   Trace ray against the screen depth buffer. Fallback to light-probes if ray exits the view.

Resolution
:   Resolution at which the ray-tracing is performed.
    Lower options will be faster and use less memory but will produce blurrier results.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Type
:   Radial:
    :   Radially distorts the image to create a barrel or a Pincushion distortion.

    Horizontal:
    :   Horizontally distorts the image to create a channel/color shifting effect.

Distortion Radial
:   This creates a bulging or pinching effect from the center of the image.

Dispersion
:   This simulates chromatic aberrations, where different wavelengths of light refract slightly differently,
    creating a rainbow colored fringe.

Jitter
:   Adds jitter to the distortion. Faster, but noisier.

Fit Radial
:   Scales image so black areas are not visible. Only works for positive distortion.
user: How do I use MASK_UL_layers(UIList) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MASK_UL_layers(UIList)

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

*class* bpy.types.MASK_UL_layers(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

    *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 NodeTreeInterfaceSocketIntUnsigned(NodeTreeInterfaceSocket), preserving all code examples.

assistant: # NodeTreeInterfaceSocketIntUnsigned(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketIntUnsigned(*NodeTreeInterfaceSocket*)
:   Integer number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Iterations
:   The filter can be applied multiple times by chaining the node multiple times.
    This chaining can produce more flat filtering.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_filter_kuwahara-node_original.webp   Original. | ../../../_images/compositing_types_filter_kuwahara-node_iterations1.webp   Iterations: 1. |
    | ../../../_images/compositing_types_filter_kuwahara-node_iterations2.webp   Iterations: 2. | ../../../_images/compositing_types_filter_kuwahara-node_iterations3.webp   Iterations: 3. |

Performance
:   The filter can be expensive to compute for high size input and high resolution
    images. To improve performance, consider scaling down the image, applying the
    filter, then scaling it up again. This can work well because the filter
    already attenuates low frequency details.
user: Provide the full official documentation entry for MaskModifier(Modifier), preserving all code examples.

assistant: # MaskModifier(Modifier)

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

*class* bpy.types.MaskModifier(*Modifier*)
:   Mask modifier to hide parts of the mesh

    armature
    :   Armature to use as source of bones to mask

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

    invert_vertex_group
    :   Use vertices that are not part of region defined

        Type:
        :   boolean, default False

    mode
    :   Type:
        :   enum in [`'VERTEX_GROUP'`, `'ARMATURE'`], default `'VERTEX_GROUP'`

    threshold
    :   Weights over this threshold remain

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

    use_smooth
    :   Use vertex group weights to cut faces at the weight contour

        Type:
        :   boolean, default False

    vertex_group
    :   Vertex group name

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Working with Multiple Objects in Blender? Include parameters, examples, warnings and best practices.

assistant: # Working with Multiple Objects

Unlike Edit Mode, there is no multi-object editing supported for Sculpt Mode. Since sculpting often involves editing
many separate objects, it is recommended to use the shortcut `Alt` `Q` while pointing at other objects, for
[Switching Objects](../../../editors/3dview/modes.xhtml#bpy-ops-object-transfer-mode) quickly.

[image reference removed]

The advantage of using multiple objects is that each can have its own origin and modifiers.
Splitting the geometry among multiple objects can also improve the sculpt mode performance.
Alternatively objects can also be [joined](../../../scene_layout/object/editing/join.xhtml)
so there is no need to switch objects.

[image reference removed]

In the case that Face Sets were already used, joining objects or creating new geometry in Edit Mode will
automatically assign new Face Sets. This makes it immediately possible to target each new geometry, for example via
auto-masking. If no Face Sets are created, use the [Initialize Face Sets](../editing/face_sets.xhtml#bpy-ops-sculpt-face-sets-init) operator to create them.

Face Sets and Masked geometry can also be extracted via [Mask Extract](../editing/mask.xhtml#bpy-ops-sculpt-paint-mask-extract)
or sliced into a new object via [Mask Slice](../editing/mask.xhtml#bpy-ops-sculpt-paint-mask-slice).
user: Provide the full official documentation entry for Boundary, preserving all code examples.

assistant: # Boundary

Similar to the [Pose](pose.html) brush
but deforms the open boundaries of a mesh.
The tool detects the mesh boundary closest to the active vertex and
propagates the deformation using the brush [Falloff](../../brush/falloff.html) into the mesh.

The main use cases of this brush are the *Bend* and *Expand* geometry,
which leads to the best results on evenly distributed quad based topology.
Use the *Inflate*, *Grab*, *Twist*, and *Smooth* deformation modes,
to further adjustments and tweaks to the result
(which do not depend that much on a clean topology).

The boundary origin is displayed via a white line, which indicates the reach of the deformation.
The targeted boundary that will be deformed is highlighted in the brush cursor color.

If the [Deformation Target](../../brush/brush_settings.html#bpy-types-brush-deform-target)
is changed, the brush can also be used for cloth sculpting.
user: Explain Selecting Nodes in complete detail according to the official Blender documentation.

assistant: # Selecting Nodes

Nodes in the editor can be selected and manipulated.
Selections determine which nodes can be moved, duplicated, or connected.
The active node (last selected) is highlighted with a lighter outline.
It serves as the reference for certain operations, such as grouping or linking,
and also determines which properties are displayed in the *Sidebar* and *Properties Editor*.

Nodes are selected with `LMB`.
Multiple nodes can be selected by holding `Shift`-`LMB`.

Blender also provides a variety of selection tools and shortcuts for quickly choosing nodes
based on their type, connections, or layout.
user: Show practical ways to work with DynamicPaintModifier(Modifier) in a Blender add-on or script – include code.

assistant: # DynamicPaintModifier(Modifier)

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

*class* bpy.types.DynamicPaintModifier(*Modifier*)
:   Dynamic Paint modifier

    brush_settings
    :   Type:
        :   [`DynamicPaintBrushSettings`](bpy.types.DynamicPaintBrushSettings.html#bpy.types.DynamicPaintBrushSettings "bpy.types.DynamicPaintBrushSettings"), (readonly)

    canvas_settings
    :   Type:
        :   [`DynamicPaintCanvasSettings`](bpy.types.DynamicPaintCanvasSettings.html#bpy.types.DynamicPaintCanvasSettings "bpy.types.DynamicPaintCanvasSettings"), (readonly)

    ui_type
    :   Type:
        :   enum in [Prop Dynamicpaint Type Items](bpy_types_enum_items/prop_dynamicpaint_type_items.html#rna-enum-prop-dynamicpaint-type-items), default `'CANVAS'`

    *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 X/Y/Z Global in Blender? Include parameters, examples, warnings and best practices.

assistant: These operations perform a non-interactive mirror along the global X, Y, or Z axis.

X Global
:   Mirrors the selection along the global X axis.

Y Global
:   Mirrors the selection along the global Y axis.

Z Global
:   Mirrors the selection along the global Z axis.
user: What is Building the Manual and how is it used in Blender Python scripting?

assistant: # Building the Manual

Converting the RST-files into pretty HTML pages is simple.

Open a terminal or Command Prompt in the `~/blender-manual` directory and simply run:

```
make
```

This is the command you should use when building the docs, however, other commands are available by typing `make
help`. This command will convert the RST-files into HTML pages and automatically open your default web browser to
view the result. The command will continue to run and watch for changes made to the RST-files and refresh the HTML
pages as necessary.

The building process may take several minutes the first time (or after any major changes), but for subsequent changes
it should only take a few seconds.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Offset
:   Determines the brick offset of the various rows.

Frequency
:   Determines the offset frequency. A value of 2 gives an even/uneven pattern of rows.

Squash
:   Amount of brick squashing.

Frequency
:   Brick squashing frequency.
user: What is Options and how is it used in Blender Python scripting?

assistant: ### Transform

Correct Face Attributes
:   Adjust geometry attributes like [UVs](../uv/index.xhtml)
    and [Color Attributes](../../../sculpt_paint/vertex_paint/index.xhtml) while transforming.

Keep Connected
:   Merge attributes connected to the same vertex while using *Correct Face Attributes*.

#### Mirror

The *Mirror* options enable symmetric transformations
of mesh elements (vertices, edges, or faces) along the selected axis.
When an element is transformed, its exact mirrored counterpart (in local space),
if present, is transformed correspondingly to maintain symmetry.

For the *Mirror* tool to function correctly, mirrored vertices must be precisely aligned with their counterparts.
If vertices are not accurately positioned at their mirror locations,
the *Mirror Axis* will not recognize them as mirrored.
For meshes with visual symmetry but differing topology,
enabling [Topology Mirror](#bpy-types-mesh-use-mirror-topology) can address this limitation.

#### Topology Mirror

*Topology Mirror* determines mirrored vertices by analyzing their relationships with other vertices in the mesh,
rather than relying solely on vertex positions.
By evaluating the overall topology, this feature allows non-symmetrical vertices to be treated as mirrored.

*Topology Mirror* requires at least one *Mirror Axis* to be enabled.

Example

This example demonstrates how to use *Topology Mirror* effectively:

1. Open a new Blender scene. Delete the default cube and add a Monkey object in the 3D Viewport.
2. Press `Tab` to switch to *Edit Mode*.
3. Disable all *Mirror* axes and move one of the Monkey object’s vertices slightly.
4. Enable the *X Axis Mirror* option but leave *Topology Mirror* disabled.
   Move the same vertex again. The *X Axis Mirror* will not affect the mirrored vertices, as they are not perfectly
   aligned.
5. Enable *Topology Mirror* and move the same vertex once more.
   The *X Axis Mirror* will now mirror the other vertex, even though they are not perfectly positioned.

#### Auto Merge

When enabled, as soon as a vertex moves closer to another one
than the *Threshold* setting, they are automatically merged.
This option affects interactive operations only
(tweaks made in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel are considered interactive too).
If the exact spot where a vertex is moved contains more than one vertex,
then the merge will be performed between the moved vertex and one of those.

Split Edges & Faces
:   Detects the intersection of each transformed edge, creating a new vertex in place
    and sectioning the edge and the face if any.

Threshold
:   Defines the maximum distance between vertices that are merged.

### UVs

Live Unwrap
:   Automatically recalculates the UV unwrapping every time an edge has its seam property changed.
    Note, this is different than the [Live Unwrap](../uv/editing.xhtml#bpy-types-spaceuveditor-use-live-unwrap)
    option in the UV Editor.
user: How do I use Setup in Blender? Include parameters, examples, warnings and best practices.

assistant: Baking requires a mesh to have a UV map, and either a Color Attribute
or an Image Texture node with an image to be baked to.
The [Active](../../glossary/index.xhtml#term-Active) [Image Texture](../shader_nodes/textures/image.xhtml)
node or [Color Attribute](../../sculpt_paint/vertex_paint/index.xhtml) is used as the baking target.

Use Render Bake in intensive light/shadow solutions,
such as AO or soft shadows from area lights. If you bake AO for the main objects,
you will not have to enable it for the full render, saving render time.
Cycles uses the render settings (samples, bounces, …) for baking.
This way the quality of the baked textures should match the result you get from the rendered scene.
user: How do I use Named Attribute Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Named Attribute Node

[image reference removed]

The *Named Attribute* node outputs the data of an attribute based on the
context of where it is connected (the [Field Context](../../fields.html#field-context)).
user: Show practical ways to work with Mix Vector Node in a Blender add-on or script – include code.

assistant: # Mix Vector Node

The *Mix Node* mixes values, colors and vectors inputs
using a factor to control the amount of interpolation.
The *Color* mode has additional blending modes.

[image reference removed]
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: ### F82 Tint

Base Color
:   Color of the material when viewed straight on.

Edge Tint
:   Color of the material when viewed at a 82° angle.

### Physical Conductor

IOR
:   Refractive index per color channel. This is the real part of a complex refractive index,
    scientifically denoted as n.

Extinction
:   Extinction coefficients per color channel. This is the imaginary part of a
    complex refractive index, scientifically denoted as k.

### Common

Roughness
:   Sharpness of the reflection; perfectly sharp at 0.0 and smoother with higher values.

Anisotropy Cycles Only
:   Amount of anisotropy. Higher values give elongated highlights along the tangent direction;
    negative values give highlights shaped perpendicular to the tangent direction.

Rotation Cycles Only
:   Rotates the direction of anisotropy, with 1.0 going full circle.

    Compared to the *Glossy BSDF* node, the direction of highlight elongation
    is rotated by 90°. Add 0.25 to the value to correct.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.

Tangent
:   Tangent used for shading; if nothing is connected the default shading tangent is used.
user: Provide the full official documentation entry for Set Attribute, preserving all code examples.

assistant: Opens a pop-up window showing the name of the [active](../../../glossary/index.html#term-Active) [attribute](../../../glossary/index.html#term-Attribute)
as well as the value of that attribute for the selected points
From there, you assign a new value to a selected attribute across all selected points.

This operator is useful for uniformly setting attribute values.