PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Navigation: syntax, arguments, return values, common patterns.

assistant: ### Lost in Space

When navigating your scene, you may accidentally navigate away from your scene and find yourself with a blank
viewport. There are two ways to fix this:

1. Select an object in the [Outliner](../editors/outliner/index.xhtml), then zoom to that object with
   View ‣ Frame Selected or `NumpadPeriod`.
2. Use `Home` to fit all objects into the 3D Viewport.

### Invisible Limit Zooming In

Sometimes, when navigating, you may be trying to zoom in but it seems that you have hit a limit to how far you can
zoom. This is because Blender uses a central point to orbit around.

In practice, this is good for modeling an object which you rotate many times to see it from all sides (like a potter
using a wheel). However, this makes it awkward to explore a scene or model an object from the ‘inside’, for example.

#### Solutions

- Use [View Dolly](../editors/3dview/navigate/navigation.xhtml#bpy-ops-view3d-dolly).
- Use [Walk/Fly Navigation](../editors/3dview/navigate/walk_fly.xhtml#dview-fly-walk).
- Use [Auto Depth](../editors/preferences/navigation.xhtml#bpy-types-preferencesinput-use-mouse-depth-navigate) and [Zoom to Mouse Position](../editors/preferences/navigation.xhtml#bpy-types-preferencesinput-use-zoom-to-mouse). These tools will make sure the distance is always the value under
  the mouse cursor.
- Use [Zoom Region](../editors/3dview/navigate/navigation.xhtml#bpy-ops-view3d-zoom-border) as it also resets the center point when zooming.
- Center the view around the mouse cursor `Alt`-`MMB`. This will take the position under the cursor and make it
  your viewpoint center.
- Use an NDOF, also known as a 3D mouse, see [configuring peripherals](../getting_started/configuration/hardware.xhtml#hardware-ndof) for more information.
user: Describe Socket Syncing from the Blender manual or Python API, including usage steps and snippets.

assistant: Closures rely on matching socket names to connect inputs and outputs correctly.
If the connected *Closure Zone* and *Evaluate Closure* nodes have mismatched signatures, Blender can synchronize them
automatically.

- A sync icon appears when the socket layout differs.
- Clicking the icon updates sockets to match the connected closure.
- Automatic syncing occurs the first time a closure is connected.
- Existing sockets are never modified automatically afterward to prevent data loss.
user: Provide the full official documentation entry for Render Layers Node, preserving all code examples.

assistant: # Render Layers Node

[image reference removed]

Renders a [View Layer](../../../../render/layers/introduction.html) and reads its
[Passes](../../../../render/layers/passes.html) into the compositing node graph.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_mesh-sequence-cache_panel.png)

Cache File
:   Data-block menu to select the Alembic or USD file.

File Path
:   Path to Alembic or USD file.

Object Path
:   The path to the Alembic or USD object inside the archive or stage.

Read Data
:   Controls which mesh data is imported from the cache file.
    You can selectively enable or disable the following:

    Vertices:
    :   Reads vertex positions and (if animated) deformations for each frame.

    Faces:
    :   Imports the mesh’s face topology and structure.

    UV:
    :   Loads UVs (texture coordinates) from the cache file.

    Color:
    :   Imports vertex color attributes from the cache file, if present.

    Attributes:
    :   Loads custom attributes (e.g., other data such as creases, custom normals, or generic attributes).

### Time

Sequence
:   Whether or not the cache is separated in a series of files.

Override Frame
:   Whether to use a custom frame for looking up data in the cache file,
    instead of using the current scene frame.

    The *Frame* value is the time to use for looking up the data in the cache file,
    or to determine which to use in a file sequence.

Frame Offset
:   Subtracted from the current frame to use for looking up the data in the cache file,
    or to determine which file to use in a file sequence.

### Velocity

Velocity Attribute
:   The name of the Alembic attribute used for generating motion blur data;
    by default, this is `.velocities` which is standard for most Alembic files.

Velocity Unit
:   Defines how the velocity vectors are interpreted with regard to time.

    Frame:
    :   The velocity unit was encoded in frames and does not need to be scale by scene FPS.

    Second:
    :   The velocity unit was encoded in seconds and needs to be scaled by the scene FPS (1 / FPS).

Velocity Scale
:   Multiplier used to control the magnitude of the velocity vector for time effects such as motion blur.
user: Show practical ways to work with Context Menu in a Blender add-on or script – include code.

assistant: Context menus are pop-ups that can be opened with `RMB`.
In most editors, it’s also possible to use the `Menu` key.
The contents of the menu depend on the location of the mouse pointer.

When invoked in an editor, the menu contains a list of operators sensitive to the editor’s mode.
When invoked over buttons and properties, common options include:

Single
:   Apply the change to a single value of a set (e.g. only the X coordinate of an object’s Location).

All
:   Apply the change to all values in a set (e.g. all coordinates of an object’s Location).

Reset to Default Value(s) `Backspace`
:   Replaces the current value by the default.

Copy Data Path `Shift`-`Ctrl`-`C`
:   Copies the Python property data path, relative to the data-block.
    Useful for Python scripting.

Copy Full Data Path `Shift`-`Ctrl`-`Alt`-`C`
:   Copies the full Python property data path including any needed context information.

Copy As New Driver
:   Creates a new driver using this property as input, and copies it to the clipboard.
    Use *Paste Driver* to add the driver to a different property, or *Paste Driver Variables*
    to extend an existing driver with a new input variable.

Copy To Selected
:   Copies the property value to the selected object’s corresponding property.
    A use case is if the Properties context is pinned.

Assign Shortcut
:   Lets you define a keyboard or mouse shortcut for an operation.
    To define the shortcut you must first move the mouse cursor over the button that pops up.
    When “Press a key” appears you must press and/or click the desired shortcut.
    Press `Esc` to cancel.

Change Shortcut
:   Lets you redefine the shortcut.

Remove Shortcut
:   Unlinks the existing shortcut.

Open File Location, Open Location Externally
:   Opens the containing folder using the operating system’s file manager.

Online Manual `F1`
:   Opens an online page of the Blender Manual in a web browser.

Online Python Reference
:   Context-sensitive access to
    the [Python API Reference](https://docs.blender.org/api/current/).

Edit Source
:   For UI development – Creates a text data-block with the source code associated with the control,
    in case the control is based on a Python script.
    In the Text Editor it points at the code line where the element is defined.

Edit Translation
:   For UI development – Points at the translation code line.
user: How do I use Scatter on Surface Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Scatter on Surface Modifier

The *Scatter on Surface* modifier 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 modifier 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 Outputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Processed image with the *Matte* applied to the images’ [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel).

Matte
:   Output matte to use for checking the quality of the key, or to manually apply
    using a [Set Alpha Node](../color/set_alpha.xhtml) or
    [Mix Node](../color/mix_color.xhtml).

Edges
:   Shows what edges were detected on the matte.
    Useful for adjusting the *Edge* *Size* and *Tolerance*.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Bundle
:   The resulting bundle that contains all items from the input bundles.

    Use the [Separate Bundle Node](separate_bundle.html) to access individual items from the combined bundle if needed.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Point Count
:   The size of the *Point* domain on any supported geometry.

Edge Count
:   The size of the *Edge* domain on meshes.

Face Count
:   The size of the *Face* domain on meshes.

Face Corner Count
:   The size of the *Face Corner* domain on meshes.

Spline Count
:   The size of the *Spline* domain on curves.

Instance Count
:   The number of top-level instances in the geometry. [Nested instances](../instances.html#geometry-nodes-nested-instancing)
    are not considered.
user: How do I use X/Y/Z Local in Blender? Include parameters, examples, warnings and best practices.

assistant: These operations perform a non-interactive mirror along the object’s local axes.

X Local
:   Mirrors the selection along the object’s local X axis.

Y Local
:   Mirrors the selection along the object’s local Y axis.

Z Local
:   Mirrors the selection along the object’s local Z axis.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Color
:   Volume scattering color.

Color Attribute
:   Volume grid for coloring the volume. Use “color” for smoke simulations.

Density
:   Density of the volume.

Density Attribute
:   Volume grid to define the density, typically “density”.

Anisotropy
:   Backward or forward scattering direction.

Absorption Color
:   Volume shadow color tint.

Emission Strength
:   Amount of light to emit.

Emission Color
:   Emission color tint.

Blackbody Intensity
:   Blackbody emission for fire. Set to 1 for physically accurate intensity.

Blackbody Tint
:   Color tint for blackbody emission.

Temperature
:   Temperature in kelvin for blackbody emission, higher values emit more.

Temperature Attribute
:   Volume grid to define the temperature, typically “temperature”.
user: Explain Constraint Type Items in complete detail according to the official Blender documentation.

assistant: # Constraint Type Items

**Motion Tracking**

CAMERA_SOLVER:
:   Camera Solver.

FOLLOW_TRACK:
:   Follow Track.

OBJECT_SOLVER:
:   Object Solver.

**Transform**

COPY_LOCATION:
:   Copy Location.

    Copy the location of a target (with an optional offset), so that they move together.

COPY_ROTATION:
:   Copy Rotation.

    Copy the rotation of a target (with an optional offset), so that they rotate together.

COPY_SCALE:
:   Copy Scale.

    Copy the scale factors of a target (with an optional offset), so that they are scaled by the same amount.

COPY_TRANSFORMS:
:   Copy Transforms.

    Copy all the transformations of a target, so that they move together.

LIMIT_DISTANCE:
:   Limit Distance.

    Restrict movements to within a certain distance of a target (at the time of constraint evaluation only).

LIMIT_LOCATION:
:   Limit Location.

    Restrict movement along each axis within given ranges.

LIMIT_ROTATION:
:   Limit Rotation.

    Restrict rotation along each axis within given ranges.

LIMIT_SCALE:
:   Limit Scale.

    Restrict scaling along each axis with given ranges.

MAINTAIN_VOLUME:
:   Maintain Volume.

    Compensate for scaling one axis by applying suitable scaling to the other two axes.

TRANSFORM:
:   Transformation.

    Use one transform property from target to control another (or same) property on owner.

TRANSFORM_CACHE:
:   Transform Cache.

    Look up the transformation matrix from an external file.

**Tracking**

CLAMP_TO:
:   Clamp To.

    Restrict movements to lie along a curve by remapping location along curve’s longest axis.

DAMPED_TRACK:
:   Damped Track.

    Point towards a target by performing the smallest rotation necessary.

IK:
:   Inverse Kinematics.

    Control a chain of bones by specifying the endpoint target (Bones only).

LOCKED_TRACK:
:   Locked Track.

    Rotate around the specified (‘locked’) axis to point towards a target.

SPLINE_IK:
:   Spline IK.

    Align chain of bones along a curve (Bones only).

STRETCH_TO:
:   Stretch To.

    Stretch along Y-Axis to point towards a target.

TRACK_TO:
:   Track To.

    Legacy tracking constraint prone to twisting artifacts.

**Relationship**

ACTION:
:   Action.

    Use transform property of target to look up pose for owner from an Action.

ARMATURE:
:   Armature.

    Apply weight-blended transformation from multiple bones like the Armature modifier.

CHILD_OF:
:   Child Of.

    Make target the ‘detachable’ parent of owner.

FLOOR:
:   Floor.

    Use position (and optionally rotation) of target to define a ‘wall’ or ‘floor’ that the owner cannot cross.

FOLLOW_PATH:
:   Follow Path.

    Use to animate an object/bone following a path.

GEOMETRY_ATTRIBUTE:
:   Geometry Attribute.

    Retrieve transform from target geometry attribute data.

PIVOT:
:   Pivot.

    Change pivot point for transforms (buggy).

SHRINKWRAP:
:   Shrinkwrap.

    Restrict movements to surface of target mesh.
user: Give a detailed overview of Merge: syntax, arguments, return values, common patterns.

assistant: At Center
:   Moves selected UVs to their average position.

At Cursor
:   Moves selection UVs to 2D cursor location.

### By Distance

Merges selected UVs within the specified *Merge Distance*.

Merge Distance
:   Maximum distance between merged vertices.

Unselected
:   Merge selected to other unselected vertices.

Shared Vertex
:   Merge UVs that correspond to the same mesh vertex, even if they have different UV coordinates.
user: Explain GeometryNodeMeshBoolean(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeMeshBoolean(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.GeometryNodeMeshBoolean(*GeometryNode*)
:   Cut, subtract, or join multiple mesh inputs

    operation
    :   - `INTERSECT`
          Intersect – Keep the part of the mesh that is common between all operands.
        - `UNION`
          Union – Combine meshes in an additive way.
        - `DIFFERENCE`
          Difference – Combine meshes in a subtractive way.

        Type:
        :   enum in [`'INTERSECT'`, `'UNION'`, `'DIFFERENCE'`], default `'INTERSECT'`

    solver
    :   - `EXACT`
          Exact – Slower solver with the best results for coplanar faces.
        - `FLOAT`
          Float – Simple solver with good performance, without support for overlapping geometry.
        - `MANIFOLD`
          Manifold – Fastest solver that works only on manifold meshes but gives better results.

        Type:
        :   enum in [`'EXACT'`, `'FLOAT'`, `'MANIFOLD'`], 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: Provide the full official documentation entry for Line Art Modifier, preserving all code examples.

assistant: # Line Art Modifier

The *Line Art* modifier generates stylized Line Art from a scene, collection, or object.

In order for the effects of the modifier to be visible, the scene must have an active camera.
The generated lines are only generated on portions of the object that a visible from this camera.
user: What is GeometryNodeInputCurveTilt(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeInputCurveTilt(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.GeometryNodeInputCurveTilt(*GeometryNode*)
:   Retrieve the angle at each control point used to twist the curve’s normal around its tangent

    *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 Faces by Edges in complete detail according to the official Blender documentation.

assistant: *Faces by Edges* is similar to the *Rip* tool. When two or more touching interior edges,
or a border edge is selected, a hole will be created,
and the selected edges will be duplicated to form the border of the hole.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_split_edges-before.png   Selected edges. | ../../../../_images/modeling_meshes_editing_mesh_split_edges-after.png   Adjacent face moved to reveal hole left by split. |
user: Give a detailed overview of ObjectLineArt(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ObjectLineArt(bpy_struct)

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

*class* bpy.types.ObjectLineArt(*bpy_struct*)
:   Object Line Art settings

    crease_threshold
    :   Angles smaller than this will be treated as creases

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

    intersection_priority
    :   The intersection line will be included into the object with the higher intersection priority value

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

    usage
    :   How to use this object in Line Art calculation

        - `INHERIT`
          Inherit – Use settings from the parent collection.
        - `INCLUDE`
          Include – Generate feature lines for this object’s data.
        - `OCCLUSION_ONLY`
          Occlusion Only – Only use the object data to produce occlusion.
        - `EXCLUDE`
          Exclude – Don’t use this object for Line Art rendering.
        - `INTERSECTION_ONLY`
          Intersection Only – Only generate intersection lines for this collection.
        - `NO_INTERSECTION`
          No Intersection – Include this object but do not generate intersection lines.
        - `FORCE_INTERSECTION`
          Force Intersection – Generate intersection lines even with objects that disabled intersection.

        Type:
        :   enum in [`'INHERIT'`, `'INCLUDE'`, `'OCCLUSION_ONLY'`, `'EXCLUDE'`, `'INTERSECTION_ONLY'`, `'NO_INTERSECTION'`, `'FORCE_INTERSECTION'`], default `'INHERIT'`

    use_crease_override
    :   Use this object’s crease setting to overwrite scene global

        Type:
        :   boolean, default False

    use_intersection_priority_override
    :   Use this object’s intersection priority to override collection setting

        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 Is Edge Manifold Node in complete detail according to the official Blender documentation.

assistant: # Is Edge Manifold Node

[image reference removed]

The *Is Edge Manifold* node outputs a boolean value indicating whether each edge in a mesh
is *manifold*. A manifold edge is shared by exactly two faces and has consistent face normals,
meaning it is part of a continuous surface without gaps or branching edges.

This node is useful for detecting mesh topology issues or isolating boundary or non-manifold edges.
user: Show practical ways to work with SpreadsheetTableID(bpy_struct) in a Blender add-on or script – include code.

assistant: # SpreadsheetTableID(bpy_struct)

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

subclasses —
[`SpreadsheetTableIDGeometry`](bpy.types.SpreadsheetTableIDGeometry.html#bpy.types.SpreadsheetTableIDGeometry "bpy.types.SpreadsheetTableIDGeometry")

*class* bpy.types.SpreadsheetTableID(*bpy_struct*)
:   Data used to identify a spreadsheet table

    type
    :   The type of the table identifier

        - `GEOMETRY`
          Geometry – Table contains geometry data.

        Type:
        :   enum in [`'GEOMETRY'`], default `'GEOMETRY'`, (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](#bpy.types.SpreadsheetTableID.type "bpy.types.SpreadsheetTableID.type")
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

The Smooth Corrective modifier.

Factor
:   The factor to control the smoothing amount.
    Higher values will increase the effect.

    Values outside expected range (above 1.0 or below 0.0) will distort the mesh.

Repeat
:   The number of smoothing iterations,
    equivalent to executing the *Smooth* tool multiple times.

Scale
:   Additional scaling factor to increase the size of the mesh.
    This is useful because sometimes the Smooth Corrective modifier
    will introduce volume loss, especially when used with a rig.

Smooth Type
:   Select the smoothing method used.

    Simple
    :   This simply relaxes vertices to their connected edges.

    Length Weight
    :   Uses a method of relaxing that weights by the distance of surrounding vertices.
        This option can give higher quality smoothing in some cases,
        by better preserving the shape of the original form.

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.
    This allows for selective, real-time smoothing, by painting vertex weights.

Only Smooth
:   This option is included to preview the smoothing used, before correction is applied.

Pin Boundaries
:   Prevent boundary vertices from smoothing.

Rest Source
:   Select the source for reference vertex positions that defines the non-deformed state.

    Original Coordinates
    :   Use the original input vertex positions.
        This relies on the original mesh having the same number of vertices as the input, modified mesh.

    Bind Coordinates
    :   Optionally you may bind the modifier to a specific state.
        This is required when there are constructive modifiers such as *Subdivision Surface* or *Mirror*
        in the stack before this modifier.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Vector
:   Vector to be rotated.

Center
:   Point to rotate around.

Axis
:   Axis to rotate around.

Angle
:   Angle to rotate the input vector by.

Rotation
:   When *Type* is set to *Euler*, rotate the input vector
    by these angles around the X, Y, then Z axes in that order.
user: Describe Select Linked from the Blender manual or Python API, including usage steps and snippets.

assistant: Selects all the bones in the chain which the active (last selected) bone belongs to.

All Forks
:   Selects all bones connected to the active bone even if the branch off from the current bone.

Linked bones selection.

|  |  |
| --- | --- |
| <../../../_images/animation_armatures_bones_selecting_single-bone.png>   A single selected bone. | <../../../_images/animation_armatures_bones_selecting_whole-chain.png>   Its whole chain selected with Linked. |
user: Give a detailed overview of Interface: syntax, arguments, return values, common patterns.

assistant: ### Header

Node Tree Sub-Type
:   Geometry Nodes can have multiple contexts depending on the intended function of the node group.
    Changing the context adjusts the user interface to best fit the needs of the selected context.

    Modifier:
    :   Used to create node groups that will be used by the [Geometry Nodes Modifier](../modeling/modifiers/geometry_nodes.xhtml).

    Tool:
    :   Used to create node groups that will be used to create [Node-Based Tools](../modeling/geometry_nodes/tools.xhtml).

View
:   Standard view menu.

Select
:   Menu for [Selecting Nodes](../interface/controls/nodes/selecting.xhtml).

Add
:   Menu for adding new [Geometry Nodes](../modeling/geometry_nodes/index.xhtml).

Node
:   Menu for [Editing Nodes](../interface/controls/nodes/editing.xhtml).

---

Geometry Node Group
:   [Data-Block Menu](../interface/controls/templates/data_block.xhtml) for creating and selecting node groups.

/ Pinned
:   The pin button will keep the current node group selection fixed,
    instead of using the [Active Modifier](../modeling/modifiers/introduction.xhtml#modifier-stack-active).
    When a node group is pinned, it will remain visible in the Geometry Node editor
    even when another object or modifier is selected elsewhere.

---

Parent Node Tree
:   Jumps up a node group level. See [Edit Group](../interface/controls/nodes/groups.xhtml#bpy-ops-node-tree-path-parent) for details.

Snapping
:   Snapping options. See [Arranging Nodes](../interface/controls/nodes/arranging.xhtml) for details.

Overlays
:   See [Overlays](../interface/controls/nodes/node_editors.xhtml#bpy-types-spacenodeoverlay-show-overlays).

### Toolbar

Select
:   See [Selecting Nodes](../interface/controls/nodes/selecting.xhtml).

Annotate
:   See [Annotations](../interface/annotate_tool.xhtml).

Links Cut
:   See [Cut Links](../interface/controls/nodes/editing.xhtml#bpy-ops-node-links-cut).

### Sidebar

#### Node

This tab gives access to the active node’s properties.

#### Tool

This tab gives access to the active tool’s settings.

#### View

This tab allows managing annotations.

#### Group

This tab allows you to edit the current node group’s inputs and outputs.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Domain
:   Which [attribute domain](../attributes_reference.html#attribute-domains) to process.

Inspection Index
:   Geometry element index that is used by inspection features like the [Viewer Node](../output/viewer.html)
    or [socket inspection](../inspection.html).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: The inputs of the node are dynamic. Some inputs are only available for certain operations.
For instance, the *Addend* input is only available for the *Multiply Add* operator.

Value
:   Input Value. Trigonometric functions read this value as radians.

Addend
:   Input Addend.

Base
:   Input Base.

Exponent
:   Input Exponent.

Epsilon
:   Input Epsilon.

Distance
:   Input Distance.

Min
:   Input Minimum.

Max
:   Input Maximum.

Increment
:   Input Increment.

Scale
:   Input Scale.

Degrees
:   Input Degrees.

Radians
:   Input Radians.
user: Explain VDM Displacement in complete detail according to the official Blender documentation.

assistant: *Vector Displacement Maps* are supported for the *Draw* brush to insert complex & overhanging shapes.
Unlike regular displacement, this uses all 3 color channels of the image
to displace geometry in three directions instead of just one.

[[image reference removed]](../../../_images/sculpt-paint_sculpt_vdm_example.png)

An example of various VDM brushes used on a smooth head from the official demo file.

[Download the demo file](https://www.blender.org/download/demo-files/#sculpting)
for more information and to try the feature out.

To use this feature, enable [Vector Displacement](../../brush/texture.html#bpy-types-brush-use-color-as-displacement) in the texture
panel. All [stroke methods](../../brush/stroke.html#bpy-types-brush-stroke-method) are supported, but the recommended behavior is
*Anchored*.

Ideal images for vector displacement are open EXR files
with [color clamping](../../../render/materials/legacy_textures/colors.html) disabled.
user: Explain Surfaces in complete detail according to the official Blender documentation.

assistant: # Surfaces

The surface shader defines the light interaction at the surface of the mesh.
One or more BSDFs specify
if incoming light is reflected back, refracted into the mesh, or absorbed.

Emission defines how light is emitted from the surface,
allowing any surface to become a light source.
user: How do I use Asset System Files (.asset.blend Extension) in Blender? Include parameters, examples, warnings and best practices.

assistant: Some types of assets can be edited without having to open a blend-file inside of an asset library.
Blender saves these assets to libraries in special files using the .asset.blend extension. They
are entirely managed by Blender’s asset system, and only contain a single asset and its
dependencies.

It is still possible to save a normal file with the .asset.blend extension. This will then not
be treated as an asset system file, Blender knows the difference.

Asset system files have one more special characteristic: You can open, but not save them. The
[Save As](../blend/open_save.xhtml#bpy-ops-wm-save-as-mainfile) operator can still be used to create a new file from
them, which will then be just a normal blend-file. Thus contained assets cannot be edited without
opening the file itself. Blender shows some clear warnings to communicate that asset system files
cannot be changed and saved the normal way.

The reason these files are special is that the asset system might need to regenerate them. Any
additional changes done by the user might be lost then. To prevent this data-loss, these files are
protected from user modifications.

Currently, only brush assets support this feature.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.xhtml)
:   General and advanced settings.

[Texture](../../brush/texture.xhtml)
:   Color and mask texture settings.

[Stroke](../../brush/stroke.xhtml)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.xhtml)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.xhtml)
:   Cursor and appearance settings.
user: Show practical ways to work with NodeLink(bpy_struct) in a Blender add-on or script – include code.

assistant: # NodeLink(bpy_struct)

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

*class* bpy.types.NodeLink(*bpy_struct*)
:   Link between nodes in a node tree

    from_node
    :   Type:
        :   [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (readonly)

    from_socket
    :   Type:
        :   [`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (readonly)

    is_hidden
    :   Link is hidden due to invisible sockets

        Type:
        :   boolean, default False, (readonly)

    is_muted
    :   Link is muted and can be ignored

        Type:
        :   boolean, default False

    is_valid
    :   Link is valid

        Type:
        :   boolean, default False

    multi_input_sort_id
    :   Used to sort multiple links coming into the same input. The highest ID is at the top.

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

    to_node
    :   Type:
        :   [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (readonly)

    to_socket
    :   Type:
        :   [`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (readonly)

    swap_multi_input_sort_id(*other*)
    :   Swap the order of two links connected to the same multi-input socket

        Parameters:
        :   **other** ([`NodeLink`](#bpy.types.NodeLink "bpy.types.NodeLink"), (never None)) – Other, The other link. Must link to the same multi-input 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: Give a detailed overview of BoidRuleFollowLeader(BoidRule): syntax, arguments, return values, common patterns.

assistant: # BoidRuleFollowLeader(BoidRule)

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

*class* bpy.types.BoidRuleFollowLeader(*BoidRule*)
:   distance
    :   Distance behind leader to follow

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

    object
    :   Follow this object instead of a boid

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

    queue_count
    :   How many boids in a line

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

    use_line
    :   Follow leader in a line

        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: What is face.skin_jaw and how is it used in Blender Python scripting?

assistant: Implements a skin system [parent controller](skin.xhtml#rigify-rigs-skin-skin-parents) that manages
one or more loops of mouth skin chains in response to the movement of jaw and mouth controls.

The rig must have one or more child chain loops, each formed by four skin chains tagged
with `.T`/`.B` and `.L`/`.R` symmetrical names.

The lip loops are sorted into layers based on the distance from corners to the common
center and rigged with blended influence of the jaw and the master mouth control.
Other child rigs become children of the jaw.

Bottom Lip Influence
:   Specifies the influence of the jaw on the inner bottom lip with mouth lock disabled.

Locked Influence
:   Specifies the influence of the jaw on both lips of locked mouth.

Secondary Influence Falloff
:   Specifies the factor by which influence fades away with each successive lip loop
    (for bottom lip loops the blend moves away from inner bottom lip to full jaw influence).
user: Show practical ways to work with Tools in a Blender add-on or script – include code.

assistant: ### Comb

Moves the keypoints (similar to the Proportional Editing tool).

Deflect Emitter
:   Hair particles only – Do not move keypoints through the emitting mesh.

    Distance
    :   The distance to keep from the Emitter.

### Smooth

Parallels visually adjacent segments.

### Add

Adds new particles.

Count
:   The number of new particles per step.

Interpolate
:   Interpolate the shape of new hairs from existing ones.

Steps
:   Amount of brush steps.

Keys
:   How many keys to make new particles with.

### Length

Scales the segments, so it makes the hair longer with *Grow* or shorter with *Shrink*.

Grow/Shrink
:   Sets the brush to add the effect or reverse it.

### Puff

Rotates the hair around its first keypoint (root).
So it makes the hair stand up with *Add* or lay down with *Sub*.

Puff Volume
:   Apply puff to unselected end points, (Helps to maintain the hair volume when puffing the root.)

### Cut

Scales the segments until the last keypoint reaches the brush.

### Weight

This is especially useful for soft body animations, because the weight defines the soft body *Goal*.
A keypoint with a weight of 1 will not move at all,
a keypoint with a weight of 0 subjects fully to soft body animation.
This value is scaled by the Strength *Min* to *Max* range of soft body goals…

### Common Options

Below the brush types, their settings appear:

Radius `F`
:   Set the radius of the brush.

Strength `Shift`-`F`
:   Set the strength of the brush effect (not for Add brush).
user: Explain Import STL Node in complete detail according to the official Blender documentation.

assistant: # Import STL Node

[image reference removed]

The *Import STL* node imports mesh geometry from a .stl (Stereolithography) file.

STL files are commonly used for 3D printing and CAD applications and contain only surface geometry,
typically as a collection of triangles with no color, texture, or other attributes.

This node enables incorporating external STL assets into Geometry Nodes for procedural processing or visualization.
user: What is Spin and how is it used in Blender Python scripting?

assistant: Similar to its [mesh counterpart](../../meshes/tools/spin.xhtml), this operator
extrudes the selected control points several times along a circle that’s centered on
the [3D Cursor](../../../editors/3dview/3d_cursor.xhtml) and parallel to the viewing plane.
The [weights](../structure.xhtml#modeling-surfaces-weight) of the new control points are set up
to produce a circle, and the surface is marked as *Cyclic*, *Bézier*, and *Endpoint*
in the extrusion direction (see [Active Spline](../properties/active_spline.xhtml)).
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_bisect_example.png   Example of a common use of bisect. | ../../../../_images/modeling_meshes_editing_mesh_bisect_uv.jpg   Example of bisect with the fill option enabled. |
user: Show practical ways to work with Baking in a Blender add-on or script – include code.

assistant: Bake
:   Start baking.
    Blender will become unresponsive during most baking operations.
    The cursor will display as a number representing the progress of the baking.
    You need to be in Object Mode to bake.

Delete Bake
:   Mark the baked cache as temporary. The data will still exist,
    but will be removed with the next object modification and frame change.
    This button is only available when the physics system has been baked.

Calculate to Frame
:   Bake only up to the current frame. Limited by *End* frame set in the cache settings.

Current Cache to Bake
:   Store any temporarily cached simulation data as a bake.
    Note that playing the animation will try to simulate any visible physics simulations.
    Depending on the physics type, this data may be temporarily cached.
    Normally such temporary caches are cleared when an object or setting is
    modified, but converting it to a bake will “save” it.

Bake All Dynamics
:   Bake all physics systems in the scene, even those of different types.
    Useful for baking complex setups involving interactions between different physics types.

    See [Bake](#physics-bake).

Delete All Bakes
:   Delete bakes of all physics systems in the scene, even those of different types.

    See [Delete Bake](#delete-physics-bake) for more information.

Update All to Frame
:   Bake all physics systems in the scene to the current frame.

    See [Calculate To Frame](#calc-physics-bake-to-frame).
user: How do I use CurvesModifier(StripModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CurvesModifier(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.CurvesModifier(*StripModifier*)
:   RGB curves modifier for sequence strip

    curve_mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

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

assistant: When enabled (the default), the UV Editor and 3D Viewport share a synchronized selection state.
Selecting components (vertices, edges, or faces) in one editor will automatically select the
corresponding elements in the other.

With *Sync Selection* enabled, all faces are visible in the UV Editor at all times. Selecting a
vertex, edge, or face in the 3D Viewport selects its corresponding UV elements. However, when a
single 3D vertex or edge corresponds to multiple UV vertices or edges (for example, along a UV seam),
you cannot select them individually—selecting one selects all of them.

When disabled, only the UVs belonging to the currently selected faces in the 3D Viewport are shown.
Selections in the UV Editor are independent, allowing individual UV vertices and edges to be selected
even if they correspond to the same mesh vertex or edge. Selecting in one editor no longer affects
the other.
user: What is Group Input and how is it used in Blender Python scripting?

assistant: Exposes the inputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
bringing in each input right where you need it (rather than dragging long links all across your graph).

The input slots can be edited in the *Group* tab of the *Sidebar*.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Color1, Color 2
:   Color of the checkers.

Scale
:   Overall texture scale. The scale is a factor of the bounding box of the face divided by the scale.
    For example, a scale of 15 will result in 15 alternate patterns over the overall UV bounding box.
    Different patterns could be achieved using other nodes to give different input patterns to this socket.
    For example, using the Math node.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Vertices
:   Number of vertices in the top and/or bottom circle of the cone.
    No geometry is generated if the number is below three.

Side Segments
:   Number of vertically stacked face loops that make up the cone’s sides.
    Increasing this will add horizontal cuts.
    No geometry is generated if the number is below one.

Fill Segments
:   Number of concentric rings in the top and/or bottom.
    No geometry is generated if the number is below one.

Radius Top
:   The radius of the cone’s top circle.
    If this is zero, the circle is reduced to a single vertex.

Radius Bottom
:   Same as *Radius Top* but for the bottom circle.

Depth
:   Height of the generated cone.
user: Give a detailed overview of Extension Licenses: syntax, arguments, return values, common patterns.

assistant: # Extension Licenses

The [Blender Extensions Platform](https://extensions.blender.org)
only supports free and open source extensions compliant with the
[Blender’s license](https://www.blender.org/about/license):

- For add-ons, the required license is
  [GNU General Public License v3.0 or later](https://spdx.org/licenses/GPL-3.0-or-later.html).
- For themes, the recommended license is
  [GNU General Public License v3.0 or later](https://spdx.org/licenses/GPL-3.0-or-later.html),
  but any [GPL-compatible license](https://www.gnu.org/licenses/license-list.en.html#GPLCompatibleLicenses)
  is supported.
- For assets used in add-ons, the required license is
  [Public Domain (CC0)](https://spdx.org/licenses/CC0-1.0.html).