PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Attribute Conversion Operator in a Blender add-on or script – include code.

assistant: [image reference removed]

This operator found in the *Attributes* panel of the property editor can change the
domain or data type of an attribute.

Due to ongoing development in the area of attributes, many areas of Blender can not yet work with
the generic (identified with a name, stored on any domain with any data type) attributes used by
geometry nodes. That makes this operator an essential workaround in some cases where existing
tools must be used with data generated from geometry nodes.

Mode
:   Generic:
    :   Interpolate and convert the attribute between the domains and data types described on this page.

    Vertex Group:
    :   Create a [Vertex Group](../meshes/properties/vertex_groups/index.html)
        from the attribute, which corresponds to a float attribute on the point domain.
user: What is Options and how is it used in Blender Python scripting?

assistant: Mode
:   Keyframes:
    :   Shows Keyframes in the range determined by the *Before*/*After* settings.

    Frames:
    :   Shows Frames in the range determined by the *Before*/*After* settings.

    Selected:
    :   Shows only on the manually selected keyframes in the Dope Sheet.

Opacity
:   Control the opacity of the ghost frames.

Filter by Type
:   Filters what type of frames to show in the Onion Skinning range.

Keyframes Before/After
:   Sets how many frames or keyframes, depending on the *Mode*, to show before and after the current frame.
user: Provide the full official documentation entry for Create Guide Index Map, preserving all code examples.

assistant: # Create Guide Index Map

The *Create Guide Index Map* node generates an integer attribute named
`guide_curve_index` that maps every hair curve to its nearest *guide* curve.
Each non-guide curve is assigned the index of the guide curve it should follow.

This guide map is used by other hair grooming nodes (for example,
[Braid Hair Curves](braid_hair_curves.html),
[Clump Hair Curves](clump_hair_curves.html))
to organize curves into logical groups around shared guides and apply
effects consistently.

Other nodes in the [Hair Guides Nodes](index.html)
category can generate a guide map internally for convenience, but the
resulting attribute is equivalent to what this node produces.
user: Provide the full official documentation entry for Smooth Corrective Modifier, preserving all code examples.

assistant: # Smooth Corrective Modifier

The *Smooth Corrective* modifier is used to reduce highly distorted areas of a mesh by smoothing the deformations.

This is typically useful *after* an [Armature modifier](armature.html),
where distortion around joints may be hard to avoid, even with careful weight painting.

To use this modifier effectively, it is important to understand the basics of how it works.

Rest State
:   Used as a reference to detect highly distorted areas.
    The original vertex locations are used by default.

Smoothing
:   Many options for this modifier relate to smoothing which is used internally
    to correct the distorted regions.
user: Provide the full official documentation entry for Bpy.Ops.Surface, preserving all code examples.

assistant: ign (enum in [ 'WORLD' , 'VIEW' , 'CURSOR' ], (optional)) – Align, The alignment of the new object WORLD World – Align the new object to the world. VIEW View – Align the new object to the view. CURSOR 3D Cursor – Use the 3D cursor orientation for the new object. location ( mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object rotation ( mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object scale ( mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object bpy.ops.surface. primitive_nurbs_surface_torus_add ( * , radius = 1.0 , enter_editmode = False , align = 'WORLD' , location = (0.0, 0.0, 0.0) , rotation = (0.0, 0.0, 0.0) , scale = (0.0, 0.0, 0.0) ) ¶ Construct a Nurbs surface Torus Parameters : radius ( float in [ 0 , inf ] , ( optional ) ) – Radius enter_editmode ( boolean , ( optional ) ) – Enter Edit Mode, Enter edit mode when adding this object align (enum in [ 'WORLD' , 'VIEW' , 'CURSOR' ], (optional)) – Align, The alignment of the new object WORLD World – Align the new object to the world. VIEW View – Align the new object to the view. CURSOR 3D Cursor – Use the 3D cursor orientation for the new object. location ( mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object rotation ( mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object scale ( mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object Next Text Operators Previous Spreadsheet Operators Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Surface Operators primitive_nurbs_surface_circle_add() primitive_nurbs_surface_curve_add() primitive_nurbs_surface_cylinder_add() primitive_nurbs_surface_sphere_add() primitive_nurbs_surface_surface_add() primitive_nurbs_surface_torus_add()
user: How do I use Slide Vertices in Blender? Include parameters, examples, warnings and best practices.

assistant: # Slide Vertices

Vertex Slide will transform a vertex along one of its adjacent edges.
Use `Shift`-`V` to activate tool.
The nearest selected vertex to the mouse cursor will be the control one.
Move the mouse along the direction of the desired edge to specify the vertex position.
Then press `LMB` to confirm the transformation.

Even `E`
:   By default, the offset value of the vertices is a percentage of the edges length along which they move.
    When Even mode is active, the vertices are shifted by an absolute value.

Flipped `F`
:   When Flipped is active, vertices move the same distance from adjacent vertices,
    instead of moving from their original position.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_slide-vertices_example-1.png   Selected vertex. | ../../../../_images/modeling_meshes_editing_vertex_slide-vertices_example-2.png   Positioning vertex interactively. | ../../../../_images/modeling_meshes_editing_vertex_slide-vertices_example-3.png   Repositioned vertex. |
user: Explain ShaderNodeTexChecker(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeTexChecker(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.ShaderNodeTexChecker(*ShaderNode*)
:   Generate a checkerboard texture

    color_mapping
    :   Color mapping settings

        Type:
        :   [`ColorMapping`](bpy.types.ColorMapping.html#bpy.types.ColorMapping "bpy.types.ColorMapping"), (readonly, never None)

    texture_mapping
    :   Texture coordinate mapping settings

        Type:
        :   [`TexMapping`](bpy.types.TexMapping.html#bpy.types.TexMapping "bpy.types.TexMapping"), (readonly, never None)

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

assistant: # TransformOrientation(bpy_struct)

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

*class* bpy.types.TransformOrientation(*bpy_struct*)
:   matrix
    :   Type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 3 \* 3 items in [-inf, inf], default ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0))

    name
    :   Name of the custom transform orientation

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

assistant: Automatically performs the common steps needed to prepare a scene for match moving and compositing.

This operator sets up a basic VFX workflow by:

- Creating reference objects for the floor and a test object (a cube) to verify the track.
- Creating and configuring a camera object that matches the tracked motion.
- Setting up a compositor node tree that combines the rendered 3D scene with the background footage.

The resulting setup provides a starting point for integrating 3D objects into real footage.
user: How do I use System in Blender? Include parameters, examples, warnings and best practices.

assistant: # System

The *System* section allows you to set graphics card options, memory limits & sound settings.

If your hardware does not support some of the options described on this page,
then they will either not be displayed or be corrected on startup.

[image reference removed]

Preferences System section.
user: Show practical ways to work with Linestyle Alpha Modifier Type Items in a Blender add-on or script – include code.

assistant: # Linestyle Alpha Modifier Type Items

ALONG_STROKE:
:   Along Stroke.

CREASE_ANGLE:
:   Crease Angle.

CURVATURE_3D:
:   Curvature 3D.

DISTANCE_FROM_CAMERA:
:   Distance from Camera.

DISTANCE_FROM_OBJECT:
:   Distance from Object.

MATERIAL:
:   Material.

NOISE:
:   Noise.

TANGENT:
:   Tangent.
user: Show practical ways to work with Vertex Paint Tools in a Blender add-on or script – include code.

assistant: # Vertex Paint Tools

Brush
:   Tool to use for any of the vertex paint [brushes](brushes.html).

[Annotate](../../interface/annotate_tool.html#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../interface/annotate_tool.html#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../interface/annotate_tool.html#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: What is Usage and how is it used in Blender Python scripting?

assistant: ### Selecting a Brush

In the Tool Settings select the brush to use with the tool.
The Erase tool uses [Erase Brush](../brushes/index.xhtml#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: How do I use Setup in Blender? Include parameters, examples, warnings and best practices.

assistant: - Select the light or emissive mesh object and go to the
  [Cycles Shading panel](../cycles/object_settings/object_data.xhtml#render-cycles-object-light-linking-settings) or
  [EEVEE Shading panel](../eevee/object_settings/object_data.xhtml#render-eevee-object-light-linking-settings).
- Create a new light/shadow linking collection.
- Drag & drop objects or collections from the [Outliner](../../editors/outliner/introduction.xhtml)
  onto the list.

You can also use the [Link Data](../../scene_layout/object/editing/link_transfer/link_data.xhtml) menu for this:
select the objects, add the light to the selection, press `Ctrl`-`L`, and choose
Link Receivers/Blockers to Emitter.

Multiple light objects can use the same linking collection. They can also use an existing scene collection,
but in general, it’s recommended to create dedicated linking collections so you can change these
without affecting the scene layout.
user: Give a detailed overview of Smooth Modifier: syntax, arguments, return values, common patterns.

assistant: # Smooth Modifier

The *Smooth* Modifier changes the value of one or more stroke/points properties like:
location, strength, thickness or UV texture position
trying to maintain similar values that make the line fluid and smoother.
user: What is SequencerCompositorModifierData(StripModifier) and how is it used in Blender Python scripting?

assistant: # SequencerCompositorModifierData(StripModifier)

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

*class* bpy.types.SequencerCompositorModifierData(*StripModifier*)
:   Compositor Modifier

    node_group
    :   Node group that controls what this modifier does

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

    open_mask_input_panel
    :   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: Provide the full official documentation entry for CryptomatteEntry(bpy_struct), preserving all code examples.

assistant: # CryptomatteEntry(bpy_struct)

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

*class* bpy.types.CryptomatteEntry(*bpy_struct*)
:   encoded_hash
    :   Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    name
    :   Type:
        :   string, default “”, (readonly, 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: Give a detailed overview of TextureNodeTexMusgrave(TextureNode): syntax, arguments, return values, common patterns.

assistant: # TextureNodeTexMusgrave(TextureNode)

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"), [`TextureNode`](bpy.types.TextureNode.html#bpy.types.TextureNode "bpy.types.TextureNode")

*class* bpy.types.TextureNodeTexMusgrave(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Lighting

The Workbench engine does not use the lights of the scene.
The lighting conditions that will be used can be set in the Lighting panel.

Flat:
:   Objects are “shaded” in a flat color, without any highlights or shadows.

Studio:
:   Use a predefined studio lighting setup, such as a key light
    shining from the front and a rim light shining from the back.
    Click the sphere to choose a different setup.

    The studio lights can be configured in the [Preferences](../../editors/preferences/lights.xhtml#prefs-lights-studio).
    By default, they follow the viewport camera around, but this can be changed:

    World Space Lighting
    :   Keep the lights fixed in place rather than following the viewport camera.

    Rotation
    :   The rotation of the lights on the Z axis.

MatCap:
:   Use a Material Capture, which is an image with texturing, lighting
    and even reflections baked into it. Objects are shaded by
    simply picking colors from this image based on the direction of
    the normal in relation to the camera.

    Click the sphere to choose a different MatCap,
    or the double arrow button to flip it horizontally.

    Custom MatCaps can be loaded in the [Preferences](../../editors/preferences/lights.xhtml#prefs-lights-matcaps).
user: Give a detailed overview of Installing Dependencies: syntax, arguments, return values, common patterns.

assistant: Below are listed the installation commands for popular Linux distributions.

For the appropriate system, run the command in a terminal:

Debian/Ubuntu:

```
sudo apt-get install python3 python3-pip git git-lfs
git lfs install --skip-repo
```

Redhat/Fedora:

```
sudo dnf install python python-pip git git-lfs
git lfs install --skip-repo
```

Arch Linux:

```
sudo pacman -S python python-pip git git-lfs
git lfs install --skip-repo
```
user: What is Zoom In/Out and how is it used in Blender Python scripting?

assistant: Moves the view closer to, or further away from, the point of interest.
You can zoom in and out by rolling the `Wheel` or dragging with `Ctrl`-`MMB`.
To zoom with discrete steps, use the hotkeys `NumpadPlus` and `NumpadMinus`.

`RMB` cancels the zoom operation.
user: Give a detailed overview of GeometryNodeGetNamedGrid(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeGetNamedGrid(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.GeometryNodeGetNamedGrid(*GeometryNode*)
:   Get volume grid from a volume geometry with the specified name

    data_type
    :   Node socket data type

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

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

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

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

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

After pasting with ‘Paste Mirrored’, the mirror axes can be chosen in the
[redo panel](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last).
user: What is Properties and how is it used in Blender Python scripting?

assistant: Distribution Method
:   The method used to scatter points inside the grid volume:

    Random:
    :   Distribute points randomly inside the grid, weighted by voxel density.
        Produces a natural, stochastic scattering pattern.

    Grid:
    :   Distribute points evenly in a regular grid pattern inside the volume.
        The spacing between points is controlled by the *Spacing* input.
user: Provide the full official documentation entry for MovieTrackingPlaneTrack(bpy_struct), preserving all code examples.

assistant: # MovieTrackingPlaneTrack(bpy_struct)

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

*class* bpy.types.MovieTrackingPlaneTrack(*bpy_struct*)
:   Match-moving plane track data for tracking

    image
    :   Image displayed in the track during editing in clip editor

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

    image_opacity
    :   Opacity of the image

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

    markers
    :   Collection of markers in track

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

    name
    :   Unique name of track

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

    select
    :   Plane track is selected

        Type:
        :   boolean, default False

    use_auto_keying
    :   Automatic keyframe insertion when moving plane corners

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Gradient Type
:   Controls the type of gradient generated.

    Linear:
    :   Directly outputs the input X coordinate.

    Quadratic:
    :   Interpolates the input X coordinate quadratically.

    Easing:
    :   Uses a combination of quadratic and linear interpolation
        to generate a smooth gradient from the input X coordinate.

    Diagonal:
    :   Averages the input X and Y coordinates.

    Spherical:
    :   Creates an inverse gradient using the length of the input vector; the maximum value is at (0, 0, 0).

    Quadratic Sphere:
    :   The same as Spherical, except interpolated quadratically.

    Radial:
    :   Outputs a value based on the angle of the input around the Z axis.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Closures are useful when part of a node group’s logic should be user-defined.
For example, a terrain generator can use a closure to define tree placement:

- The [Evaluate Closure](evaluate_closure.html)
  node is placed where tree instances are distributed.
- A closure input is exposed on the group’s interface.
- A [Closure](closure.html)
  node is connected defining any custom placement logic.

When the closure is evaluated, the contents of the connected node graph
are executed inside the context of the terrain generator.
This allows the generator to provide stable infrastructure
(e.g., scattering, masks, attributes) while users supply their own functional behavior.

[image reference removed]

A terrain generator node group using closures for custom tree placement.
user: Provide the full official documentation entry for Select Grouped, preserving all code examples.

assistant: Selects nodes that share similar properties with the active node.

- **Type**: Select all nodes of the same type (e.g. all *Math* nodes).
- **Color**: Select nodes with the same custom [color](node_editors.xhtml#bpy-types-node-color).
  (This refers to user-assigned editor colors, not the color data processed by nodes.)
- **Prefix/Suffix**: Select nodes whose names match the same starting or ending text.
user: Describe Accumulate Field Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Accumulate Field Node

[image reference removed]

The *Accumulate Field* node counts a running total of its input values, in the order defined
by the geometry’s [indices](../../geometry/read/input_index.html). The node’s essential
operation is just addition, but instead of only outputting the final total, it outputs the current
value at every element.
user: What is Dynamics and how is it used in Blender Python scripting?

assistant: # Dynamics

[image reference removed]

Rigid Body Dynamics panel.

Used to control the physics of the rigid body simulation.
This panel is available only for *Active* type of rigid bodies.

Damping Translation
:   Amount of linear velocity that is lost over time.

Rotation
:   Amount of angular velocity that is lost over time.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Domain
:   The type of geometry element to duplicate

    Point:
    :   Duplicate the points of meshes, curves, or point clouds.
        Any other elements will not be included in the output.

    Edge:
    :   Duplicate mesh edges. Faces will not be included in the output.

    Faces:
    :   Duplicate mesh faces. Each duplicated face will be separate,
        in other words they will not share edges with other faces.

    Spline:
    :   Individual curves from the input curves component will be duplicated.

    Instances:
    :   Input top-level instances will be duplicated.
user: Show practical ways to work with Overview in a Blender add-on or script – include code.

assistant: Closures are a socket type that represent callable node graphs.
They define a set of inputs and outputs that can be evaluated inside another node group through the
[Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.

When a closure is connected, its internal node graph is *injected* into the evaluation of the node group where it is
used. This allows procedural systems to remain flexible while exposing clear, customizable control points.

Closures can be thought of as function parameters for node groups.
They let users define operations that can be executed in a controlled environment defined by the parent node tree.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: The Ellipse Mask node supports an interactive gizmo in the node editor.
To enable it, make sure [Active Node](../../../editors/compositor.html#bpy-types-spacenodeeditor-show-gizmo-active-node) gizmo is enabled,
and select the Ellipse Mask node in the Compositor.

The gizmo allows direct manipulation of the mask shape:

- Drag edges to adjust the width or height individually.
- Drag corners to adjust width and height simultaneously.
- Drag the center cross (X) to move the mask’s position.
- Drag the center dot to rotate the mask.
- Hold `Shift` while dragging edges or corners to preserve the current aspect ratio.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_weighted-normal_panel.png)

Weighting Mode
:   The normals around a vertex will be combined to create a custom (per face corner) normal
    using various weights for each. The *Weighting Mode* defines how to compute the weights.

    Face Area
    :   Weight according to the area of the face that the normal originates.
        A larger area means that the normal from that face will get a higher weight in final result.

    Corner Angle
    :   Weight according to the angle each face forms at the vertex.
        This is the method Blender uses by default when combining face normals to compute a vertex one.

    Face Area and Angle
    :   Weights are obtained by multiplying the face area and corner angle ones.

Weight
:   Determines how strongly the weights are biased according to the face areas and/or corner angles,
    a bit like a contrast setting for a picture.

    A value of 50 means all faces are weighted uniformly.
    More than 50 means faces with higher area or angles are given even more weight (more “contrast”).
    Less than 50 means faces with higher area or angles are given lesser weights (less “contrast”).

Threshold
:   A weight-rounding threshold which means that, if two angles or areas differ by less than that threshold,
    they will get equal weights.

Keep Sharp
:   Preserve [sharp edges](../../geometry_nodes/attributes_reference.html#geometry-nodes-builtin-attributes),
    though smoothing will still happen if there are multiple faces between any two sharp edges.

Face Influence
:   Use face weights (weak, medium, or strong) as assigned by
    the [Set Strength](../../meshes/editing/mesh/normals.html) tool or
    by the *Set Strength* mode of a [Bevel](../generate/bevel.html) modifier.

    For example, if three faces meet at a vertex and have the face weights weak, medium, and strong,
    then only the normal associated with the strong face will be used to set the final result.

Vertex Group
:   If a vertex group is specified, the modifier will only affect those vertices.
    The “arrow” button to its right will invert the selection (only affect the vertices *not* in the vertex group).
user: Describe Naming Conventions from the Blender manual or Python API, including usage steps and snippets.

assistant: These attributes do not exist by default, but are used implicitly by certain parts of Blender.
The data type of these attributes can be changed, just like any attribute besides the built-in attributes.
However, the attributes might be expected by Blender to have a certain type.

| Name | Type | Domain | Notes |
| --- | --- | --- | --- |
| `bevel_weight_vert` | *Float* | *Point* | Used as vertex control for the bevel modifier. |
| `bevel_weight_edge` | *Float* | *Edge* | Used as edge control for the bevel modifier. |
| `crease_edge` | *Float* | *Edge* | Edge attribute used by the Subdivision Surface modifier. The values are expected to be in a range of 0 and 1. |
| `crease_vert` | *Float* | *Point* | Vertex attribute used by the Subdivision Surface modifier. The values are expected to be in a range of 0 and 1. |
| `custom_normal` | *2D 16-Bit Integer Array* | *Face Corner* | Used by [Custom Split Normals](../meshes/structure.html#modeling-meshes-normals-custom) for mesh objects. |
| `freestyle_edge` | *Boolean* | *Edge* | Used by [Edge Marks](../../render/freestyle/view_layer/line_set.html#freestyle-edge-marks) for mesh objects. |
| `freestyle_face` | *Boolean* | *Edge* | Used by [Face Marks](../../render/freestyle/view_layer/line_set.html#freestyle-face-marks) for mesh objects. |
| `rest_position` | *Vector* | *Point* | Holds the position of points or vertices from before a geometry is deformed procedurally. Can be created automatically before [Shape Keys](../../animation/shape_keys/index.html) and [Modifiers](../modifiers/introduction.html) are evaluated with the [Add Rest Position](../../animation/shape_keys/shape_keys_panel.html#bpy-types-object-add-rest-position-attribute) option. |
| `sculpt_face_set` | *Integer* | *Face* | Used by the [Sculpt Face Sets Feature](../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.html#face-sets). |
| `sculpt_mask` | *Float* | *Point* | Used by the [Sculpt Masking Feature](../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.html#sculpt-masks). |
| `surface_uv_coordinate` | *2D Vector* | *Curve* | Used to describe curve attachment locations on a mesh surface, typically used for the hair system. |
| `uv_seam` | *Boolean* | *Edge* | True if an edge is considered a boundary between UV islands when unwrapping. |
| `velocity` | *Vector* | *Point* | Used to create motion blur when rendering animations. |
user: What is Known Limitations and how is it used in Blender Python scripting?

assistant: ### Vertices Behind the Camera

When projecting geometry in a perspective view, vertices behind the camera are not properly mapped.
You can workaround this by subdividing geometry so that faces in front of the camera have correctly mapped UVs.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Grid
:   The resulting grid after advection. Each voxel value has been transported
    according to the specified velocity field and integration scheme.
    The result represents the grid state after the given *Time Step* has elapsed.
user: Give a detailed overview of Image Texture Node: syntax, arguments, return values, common patterns.

assistant: # Image Texture Node

[image reference removed]

The *Image Texture* node is used to add an image file as a texture.
The image data is sampled with the input Vector and outputs a Color and Alpha value.
user: Explain Untitled in complete detail according to the official Blender documentation.

assistant: A lot of fixes for AMD and Intel GPUs are backported into the Mesa drivers. Therefore it is recommended to install or upgrade to their latest point [releases](https://docs.mesa3d.org/relnotes.html). For certain Linux distribution versions this can be done using custom repositories. For example, using the [kisak-mesa PPA](https://launchpad.net/~kisak/+archive/ubuntu/kisak-mesa) for Ubuntu.
user: Describe Freestyle.Types from the Blender manual or Python API, including usage steps and snippets.

assistant: pes.UnaryPredicate0D.name freestyle.types.UnaryPredicate1D freestyle.types.UnaryPredicate1D.__init__() freestyle.types.UnaryPredicate1D.__call__() freestyle.types.UnaryPredicate1D.name freestyle.types.ViewEdge freestyle.types.ViewEdge.__init__() freestyle.types.ViewEdge.update_fedges() freestyle.types.ViewEdge.chaining_time_stamp freestyle.types.ViewEdge.first_fedge freestyle.types.ViewEdge.first_viewvertex freestyle.types.ViewEdge.id freestyle.types.ViewEdge.is_closed freestyle.types.ViewEdge.last_fedge freestyle.types.ViewEdge.last_viewvertex freestyle.types.ViewEdge.nature freestyle.types.ViewEdge.occludee freestyle.types.ViewEdge.qi freestyle.types.ViewEdge.viewshape freestyle.types.ViewEdgeIterator freestyle.types.ViewEdgeIterator.__init__() freestyle.types.ViewEdgeIterator.change_orientation() freestyle.types.ViewEdgeIterator.begin freestyle.types.ViewEdgeIterator.current_edge freestyle.types.ViewEdgeIterator.object freestyle.types.ViewEdgeIterator.orientation freestyle.types.ViewMap freestyle.types.ViewMap.__init__() freestyle.types.ViewMap.get_closest_fedge() freestyle.types.ViewMap.get_closest_viewedge() freestyle.types.ViewMap.scene_bbox freestyle.types.ViewShape freestyle.types.ViewShape.__init__() freestyle.types.ViewShape.add_edge() freestyle.types.ViewShape.add_vertex() freestyle.types.ViewShape.edges freestyle.types.ViewShape.id freestyle.types.ViewShape.library_path freestyle.types.ViewShape.name freestyle.types.ViewShape.sshape freestyle.types.ViewShape.vertices freestyle.types.ViewVertex freestyle.types.ViewVertex.edges_begin() freestyle.types.ViewVertex.edges_end() freestyle.types.ViewVertex.edges_iterator() freestyle.types.ViewVertex.nature freestyle.types.orientedViewEdgeIterator freestyle.types.orientedViewEdgeIterator.__init__() freestyle.types.orientedViewEdgeIterator.object
user: Give a detailed overview of Delete: syntax, arguments, return values, common patterns.

assistant: Deletes selected vertices, edges, or faces. This operation can also be limited to:

Vertices
:   Delete all vertices in current selection, removing any faces or edges they are connected to.

Edges
:   Deletes any edges in the current selection. Removes any faces that the edge shares with it.

Faces
:   Removes any faces in current selection.

Only Edges & Faces
:   Limits the operation to only selected edges and adjacent faces.

Only Faces
:   Removes faces, but edges within the face selection are retained.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field that is true for parts of the geometry to be deleted.
    Unselected points will be completely unused for the operation–
    they will not be merged into other points, and no points will merge into them either.

Mode
:   Method for choosing which vertices are merged.

    All:
    :   Merge includes all geometry including loose parts.

    Connected:
    :   Merge only includes attached geometry i.e. the modifier will not merge loose parts together.

Distance
:   The distance to use for searching for nearby points.
user: Explain Open Shading Language in complete detail according to the official Blender documentation.

assistant: # Open Shading Language

[Open Shading Language (OSL)](https://github.com/AcademySoftwareFoundation/OpenShadingLanguage)
is a programmable shading system developed for advanced rendering engines.
It allows technical artists and developers to write custom shader code using a C-like scripting language.

In Blender, OSL can be used within Cycles to define custom surface, volume, and displacement shaders.
This gives users full control over shading behavior, enabling procedural effects, advanced lighting models,
and custom geometry-based material logic that may not be possible with built-in shader nodes alone.

Unlike node-based materials, OSL shaders are authored as text scripts using Blender’s internal
[Text Editor](../../../editors/text_editor.xhtml) or loaded from external .osl or .oso files.
These scripts are then compiled and used in the Shader Editor
through the [Script Node](../../shader_nodes/utilities/script.xhtml).
user: Provide the full official documentation entry for Known Limitations, preserving all code examples.

assistant: ### Non-Contiguous Normals

Abrupt normal changes will prevent portions of the mesh from producing a smooth subdivision.
Instead, these portions with non-contiguous normals will be subdivided using the “Simple” subdivision method.

|  |  |
| --- | --- |
| ../../../_images/modeling_modifiers_generate_subdivision-surface_normal-orientation-1.png   Comparison of good normals and bad normals. | ../../../_images/modeling_modifiers_generate_subdivision-surface_normal-orientation-2.png   Side view of image on the left. |

A quick way to fix this is to [Recalculate Normals](../../meshes/editing/mesh/normals.xhtml).
If this does not work you may have to [manually flip the normals](../../meshes/editing/mesh/normals.xhtml).
user: How do I use GeometryNodeGridGradient(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeGridGradient(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.GeometryNodeGridGradient(*GeometryNode*)
:   Calculate the direction and magnitude of the change in values of a scalar grid

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

assistant: # Shrinkwrap Constraint

The *Shrinkwrap* constraint snaps an object or bone to the surface of a mesh. It’s similar
to the [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.xhtml), which snaps every vertex of a mesh to
the surface of another.

Like other constraints, the *Shrinkwrap* constraint ignores the geometry of its owner object
and purely works with its [origin](../../../scene_layout/object/origin.xhtml). This means that, if the
origin is at the object’s center, the object will clip into the target mesh instead of sitting
on its surface. This can be mitigated with the *Distance* setting.
user: What is Thickness and how is it used in Blender Python scripting?

assistant: Used to approximate the inner geometry structure of the object without heavy computation.
This is currently used for [Subsurface Scattering](../shader_nodes/shader/sss.html),
[Translucent BSDF](../shader_nodes/shader/translucent.html),
[Refraction BSDF](../shader_nodes/shader/refraction.html), and the nodes containing these effects.

If no value is plugged into the output node,
a default thickness based on the smallest dimension of the object is used.
If a value is connected it will be used as object space thickness (i.e. scaled by object transform).
A value of zero will disable the thickness approximation and treat the object as having only one interface.

This output is only used by the EEVEE render engine.