PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Curve Guide in complete detail according to the official Blender documentation.

assistant: # Curve Guide

The *Curve Guide* is used to force particles to follow a certain
path defined by a [Curve Object](../../../../modeling/curves/index.xhtml).
A typical scenario would be to move a red blood cell inside a vein,
or to animate the particle flow in a motor.
You can also use *Curve Guide* to shape certain hair strands.

Since you can animate curves as a soft body or any other usual way,
you may build very complex animations while keeping great control and keeping the simulation time to a minimum.

To make particles point in the direction of the curve, you need to set their *Orientation Axis*
to *Velocity / Hair*, enable *Dynamic*, and set their *Angular Velocity Axis* to *Velocity*,
all in the [Rotation](../../../particles/emitter/rotation.xhtml) settings of the particle system.
The [Follow Path Constraint](../../../../animation/constraints/relationship/follow_path.xhtml) and the curve’s legacy
[Follow](../../../../modeling/curves/properties/path_animation.xhtml#bpy-types-curve-use-path-follow) option won’t work for this.

A *Curve Guide* force affects all particles on the same layer, independently from their distance to the curve.
If you have several guides in a layer,
their fields add up to each other (the way you may have learned it in your physics course).
But you can limit their influence radius by changing the *Minimum Distance* (see below).

A particle follows a *Curve Guide* during its lifetime,
the velocity depends on its lifetime and the length of the path.
user: Explain Detect Features in complete detail according to the official Blender documentation.

assistant: Detects all possible features on the current frame and places markers at these features.
This operator does not take other frames into account,
so it might place markers on features which belong to moving objects.
If the camera is turning away from this shot,
no markers could be present within the frames after the camera moved away.

There are several properties for this operator:

Placement
:   Controls where to place markers.

    Whole Frame
    :   Places markers throughout the whole frame.

    Inside Annotated Area
    :   Places markers inside the area outlined with the [Annotation Tools](../../../../interface/annotate_tool.xhtml#tool-annotate).
        This can be used to outline some areas with interesting features
        and place markers only inside the outlined area.

    Outside Annotated Area
    :   Places markers outside the area outlined with the [Annotation Tools](../../../../interface/annotate_tool.xhtml#tool-annotate).
        This can be used to outline areas of no interest (like trees, humans, etc.)
        and place markers outside of these areas.

Margin
:   Controls the distance from the image boundary for created markers.
    If markers are placed too close to the image boundary,
    they will fail to track really quickly and they should be deleted manually.
    To reduce the amount of manual clean-up, this parameter can be used.

Threshold
:   Limits minimal threshold for placing markers.
    This value comes from the feature detection algorithm and it means:
    low values means most probably this feature would fail to track very soon,
    high value means it is not much such track.
    Amount of markers to be added can be controlled with this value.

Distance
:   Defines the minimal distance between placed markers.
    It is needed to prevent markers from being placed too close to each other
    (such placement can confuse the camera solver).
user: What is Cloth with Dynamic Paint and how is it used in Blender Python scripting?

assistant: Cloth with Dynamic Paint using animated vertex groups:
[Regression blend-file](https://archive.blender.org/wiki/2015/index.php/File:Cloth_dynamic_paint.blend).
Unsupported: Starting with a goal of 0 and increasing it, but still having the vertex not pinned will **not** work
(e.g. from goal = 0 to goal = 0.5) because the necessary “goal springs” cannot be generated on-the-fly.
user: How do I use Geometry in Blender? Include parameters, examples, warnings and best practices.

assistant: # Geometry

In this tab you control the geometry of your strokes.
It contains only the option to add modifiers.

As they always completely apply to the strokes’ geometry (like object modifiers do).
They take the resulting two-dimensional strokes from the Freestyle line set and
displace or deform them in various ways.

As with other modifier stacks in Blender, they are applied from top to bottom.

[image reference removed]

Line Style: Geometry.
user: Provide the full official documentation entry for Mask Node, preserving all code examples.

assistant: # Mask Node

[image reference removed]

The Mask node can be used to select a [Mask data-block](../../../movie_clip/masking/index.xhtml).
This node can be used with other nodes, for example to Invert, Multiply or Mix, or used as a factor input.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: 1. Place the timeline playhead between two existing Grease Pencil keyframes.
2. In the 3D Viewport, click and drag left to right to set the desired interpolation factor.
3. Release the mouse button to confirm and create a new *breakdown keyframe*.

The resulting keyframe contains strokes that are interpolated between the neighboring keyframes
according to the chosen factor.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

In addition to modeling and animation, Blender can be used to edit videos.
There are two possible methods for this, one being the [Compositor](../compositing/introduction.html)
and the other, described in this chapter, being the Video Sequencer.
The Video Sequencer within Blender is a complete video editing system that allows you to combine multiple
video channels and add effects to them. You can use these effects to create powerful video edits,
especially when you combine it with the animation power of Blender!

To use the Video Sequencer, you load multiple video clips and lay them end-to-end (or in some cases, overlay them),
inserting fades and transitions to link the end of one clip to the beginning of another.
Finally, you can add audio and synchronize the timing of the video sequence to match it.

[image reference removed]

Default Video Editing screen layout.
user: How do I use ViewerNodeViewerPathElem(ViewerPathElem) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ViewerNodeViewerPathElem(ViewerPathElem)

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

*class* bpy.types.ViewerNodeViewerPathElem(*ViewerPathElem*)
:   node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Light Linking

Limit light influence to specified objects, with [Light Linking](../../lights/light_linking.html#bpy-types-object-light-linking).

Receiver Collection
:   Collection of objects that will receive light emitted from the object.

### Shadow Linking

Limit shadows to specified objects, with [Light Linking](../../lights/light_linking.html#bpy-types-object-light-linking).

Shadow Blocker Collection
:   Collection of objects that will act as shadow blockers for light emitted from the object.

### Shadow Terminator

The Shadow Terminator settings help reduce artifacts that appear along the edges
of low-poly or smoothly shaded objects, especially when using bump mapping.
These artifacts occur when shading normals deviate from the actual geometry,
causing abrupt shadow breaks.

Normal Offset
:   Shifts the shadow position along the shading normal to minimize visible artifacts.
    The offset is measured in object space and is strongest at glancing angles to the light.
    A value of zero disables the bias.
    Increase this value if shadow breaks are visible, but avoid excessive values to prevent light leaks.
    The amount of faces affected by the bias is controlled by the *Geometry Offset*:

Geometry Offset
:   Controls how many faces are affected by the normal offset.
    A value of zero only affects faces at grazing angles; 1.0 affects all faces.
    Use higher values if artifacts persist, but too much offset can distort shadows, especially with bump mapping.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Floor constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone that defines the location, and optionally the rotation, of the floor.

Offset
:   Moves the virtual floor “up” or “down” by a certain distance. This makes it possible to,
    say, make foot bones stay a certain distance above the floor geometry to leave room for
    the actual feet.

Min/Max
:   The axis that’s perpendicular to the floor and points towards its “walkable” area.
    Setting this to Z creates a floor; X or Y creates a wall; and -Z creates a ceiling.

    By default, these axes correspond to the global axes.

Use Rotation
:   Use the *Target*’s local axes for *Min/Max* instead of the global axes.

[Target/Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The spaces for evaluating and limiting the coordinates of the target and owner.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Explain Miscellaneous in complete detail according to the official Blender documentation.

assistant: Slide Spline Curvature `LMB`
:   Moves the curve and/or control points by clicking on them and dragging.

Add Vertex and Slide `Ctrl`-`LMB`
:   Inserts new control points and defines handle orientations by a continued mouse drag.
    If the last point was selected, double-click will also close the curve.

Add Feather Vertex and Slide `Shift`-`Ctrl`-`LMB`
:   Inserts new feather control points that can be transformed independently of the main spline curve.
    If no feather mask is in use this will create a basic feather mask to the curve.
user: Give a detailed overview of NodeSocketFloatFrequency(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketFloatFrequency(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatFrequency(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Distribute Points in Grid and how is it used in Blender Python scripting?

assistant: # Distribute Points in Grid

[image reference removed]

The *Distribute Points in Grid* node generates points within the active region
of a voxel grid. The number and placement of points can be controlled using
the grid’s density values and various distribution parameters.

This node is useful for scattering geometry procedurally inside a volumetric
region, such as distributing particles in a fog volume, populating points in
a simulation domain, or sampling areas defined by a signed distance field (SDF)
or density grid.
user: Explain limbs.simple_tentacle in complete detail according to the official Blender documentation.

assistant: Will create a simple bendy and stretchy b-bones tentacle chain, which can optionally replicate local rotation
from preceding bones to the subsequent ones for use in cases like fingers.

Requirement: A chain of at least two connected bones.

Automation Axis (X, Y, Z, None)
:   Enables the automation on the selected axis. Multiple axis or none can be selected holding `Shift`-`LMB`.
    When enabled the subsequent control bones will copy the local rotations from the previous ones.
    The option is accessible in the controls of the final rig as a Copy Rotation constraint and
    can be disabled even after rig is generated, or at animation time.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the main controls.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Points
:   Generated point cloud.

Tangent
:   The normalized [curve tangent](../read/curve_tangent.html) at the sampled
    position, or the direct evaluated normal in *Evaluated* mode.

Normal
:   The normal value from the evaluated curve at each result point.
    This is the same value from the [Normal Node](../../geometry/read/normal.html)
    at those positions.

Rotation
:   The [Euler](../../../../glossary/index.html#term-Euler) rotation build from the *Tangent* and *Normal* outputs, for convenience.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Min Zenith
:   The minimum zenith (vertical) rotation angle.
    Defines the lower limit of the random rotation.

Max Zenith
:   The maximum zenith (vertical) rotation angle.
    Defines the upper limit of the random rotation.

ID
:   An ID to drive the random number generator seed. By default, this input uses the same value
    as the [ID Node](../geometry/read/id.html), which is the `id` attribute of the context
    geometry if it exists, and otherwise the [index](../geometry/read/input_index.html).

Seed
:   A field to [seed](../../../glossary/index.html#term-Seed) the random number generator. This can be used to produce
    a different set of random rotations even when using the same *ID* input.
user: Give a detailed overview of Mesh Cache Modifier: syntax, arguments, return values, common patterns.

assistant: # Mesh Cache Modifier

The *Mesh Cache* modifier applies animated mesh data from an external file to a mesh, allowing it to deform over time.
It is commonly used for importing animations from other applications, enabling smooth playback of cached deformations.

This modifier functions similarly to [shape keys](../../../animation/shape_keys/introduction.xhtml),
but is specifically designed for playback of externally stored animations rather than keyframe-based deformations.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   The input image in *scene linear* color space to be converted.

Invert
:   Converts from display space back to *scene linear*.
    Not all view transforms can be inverted exactly, so the result may differ from the original image.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Space
:   The input RGB color can be in one of three spaces: Tangent, Object and World space.
    Tangent space normal maps are the most common, as they support object transformation and mesh deformations.
    Object space normal maps keep sticking to the surface under object transformations,
    while World normal maps do not.

UV Map
:   Name of the UV map to derive normal mapping tangents from. When chained with an Image Texture node,
    this UV map should be the same as the UV map used to map the texture.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`XrActionMapBindings.find`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.find "bpy.types.XrActionMapBindings.find") - [`XrActionMapBindings.new`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.new "bpy.types.XrActionMapBindings.new") - [`XrActionMapBindings.new_from_binding`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.new_from_binding "bpy.types.XrActionMapBindings.new_from_binding") - [`XrActionMapBindings.new_from_binding`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.new_from_binding "bpy.types.XrActionMapBindings.new_from_binding") | - [`XrActionMapBindings.remove`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.remove "bpy.types.XrActionMapBindings.remove") - [`XrActionMapItem.bindings`](bpy.types.XrActionMapItem.html#bpy.types.XrActionMapItem.bindings "bpy.types.XrActionMapItem.bindings") - [`XrSessionState.action_binding_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_binding_create "bpy.types.XrSessionState.action_binding_create") |
user: Provide the full official documentation entry for Selecting Nodes, preserving all code examples.

assistant: # Selecting Nodes

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

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

Blender also provides a variety of selection tools and shortcuts for quickly choosing nodes
based on their type, connections, or layout.
user: Provide the full official documentation entry for Object Gizmos, preserving all code examples.

assistant: Object Gizmos allow mouse-controlled translation, rotation and scaling in the 3D Viewport.
While they’re called “object” gizmos in the popover, they also apply to other transformable
elements such as mesh vertices.

There is a separate gizmo for each operation.
Each gizmo can be used separately or in combination with the others.

A gizmo always has three color-coded axes: X (red), Y (green), and Z (blue).
You can drag an axis with `LMB` to transform along it. The Move and Scale gizmos
additionally have small colored squares for transforming along two axes in one go.

Various modifier keys can be used:

- Holding `Ctrl` at any time will toggle [snapping](../controls/snapping.xhtml)
  and also make rotation and scaling work in coarse increments.
- Holding `Shift` *after* pressing `LMB` will do the opposite of the above, “slowing down”
  the transformation relative to mouse movement to allow finer adjustments.
- Holding `Shift` *before* pressing `LMB` will perform the transformation in the plane
  that’s perpendicular to the clicked axis. See [Plane Locking](../../../scene_layout/object/editing/transform/control/axis_locking.xhtml#view3d-transform-plane-lock).

The Gizmos popover has the following settings for object gizmos:

Orientation
:   The orientation to use for the gizmo. *Default* means to use the viewport’s
    [Transform Orientation](../controls/orientation.xhtml).
    The other options override it.

Move
:   Show the gizmo to control the location.
    Dragging the small white circle allows free movement in the viewing plane.

Rotate
:   Show the gizmo to control the rotation.
    Dragging the large white circle allows rotation around the viewing direction.
    Dragging the translucent white disc within that circle (only visible when
    hovering over the gizmo) allows [trackball rotation](../../../scene_layout/object/editing/transform/rotate.xhtml#view3d-transform-trackball).

Scale
:   Show the gizmo to control the scale.
    Dragging the area between the small and large white circles scales along all three axes.

The latter three options are also available in a pie menu
if you have the *Grave Accent / Tilde Action* in the
[Keymap Preferences](../../preferences/keymap.xhtml) set to *Gizmos*.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/editors_3dview_display_gizmo_options-translate.png   Move. | ../../../_images/editors_3dview_display_gizmo_options-rotate.png   Rotate. | ../../../_images/editors_3dview_display_gizmo_options-scale.png   Scale. | ../../../_images/editors_3dview_display_gizmo_options-all.png   Combination. |
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeSimulationOutput.state_items`](bpy.types.GeometryNodeSimulationOutput.html#bpy.types.GeometryNodeSimulationOutput.state_items "bpy.types.GeometryNodeSimulationOutput.state_items") |  |
user: How do I use Extrude Region in Blender? Include parameters, examples, warnings and best practices.

assistant: # Extrude Region

Extrusion tools duplicate vertices, while keeping the new geometry connected with the original vertices.
Vertices are turned into edges and edges will form faces.

|  |  |
| --- | --- |
| <../../../_images/modeling_meshes_tools_extrude-region_vert.png>   Single vertex extruded. | <../../../_images/modeling_meshes_tools_extrude-region_edge.png>   Single edge extruded. |

This tool is of paramount importance for creating new geometry.
It allows you to create parallelepipeds from rectangles and cylinders from circles,
as well as easily creating such things as tree limbs.

The axis on which vertices and edges are extruded along can be set interactively.
Faces are extruded by default along their averaged normal.
The extrusion can be limited to a single axis by specifying an axis;
see [Axis Locking](../../../scene_layout/object/editing/transform/control/axis_locking.html).

The extrude tools differentiate in how the new geometry is connected in itself.

Only the border loop gets extruded.
The inner region of the selection gets moved unchanged with the extrusion.

|  |  |  |
| --- | --- | --- |
| <../../../_images/modeling_meshes_tools_extrude-region_face-before.png>   Selected face. | <../../../_images/modeling_meshes_tools_extrude-region_face-after.png>   During extrude. | <../../../_images/modeling_meshes_tools_extrude-region_face-after-zaxis.png>   Set to Z axis. |
user: Explain Hello World Text Example in complete detail according to the official Blender documentation.

assistant: Example of using the blf module. For this module to work we
need to use the GPU module [`gpu`](gpu.html#module-gpu "gpu") as well.

```
# Import stand alone modules.
import blf
import bpy

font_info = {
    "font_id": 0,
    "handler": None,
}

def init():
    """init function - runs once"""
    import os
    # Create a new font object, use external TTF file.
    font_path = bpy.path.abspath('//Zeyada.ttf')
    # Store the font index - to use later.
    if os.path.exists(font_path):
        font_info["font_id"] = blf.load(font_path)
    else:
        # Default font.
        font_info["font_id"] = 0

    # Set the font drawing routine to run every frame.
    font_info["handler"] = bpy.types.SpaceView3D.draw_handler_add(
        draw_callback_px, (None, None), 'WINDOW', 'POST_PIXEL')

def draw_callback_px(self, context):
    """Draw on the viewports"""
    # BLF drawing routine.
    font_id = font_info["font_id"]
    blf.position(font_id, 2, 80, 0)
    blf.size(font_id, 50.0)
    blf.draw(font_id, "Hello World")

if __name__ == '__main__':
    init()
```
user: What is Clean Up and how is it used in Blender Python scripting?

assistant: ### Clean Tracks

Identifies all tracks which matches settings from above and performs desired action on them.

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

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

Action
:   Several actions can be performed for bad tracks.

    Select
    :   They can simply be selected.

    Delete Track
    :   The whole track can be deleted.

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

### Filter Tracks

This operator deletes obviously bad tracks (for example, the ones which are too short).
Additionally, it identifies tracks which has suspicious spikes in their motion and selects them.
user: What is CollectionExport(bpy_struct) and how is it used in Blender Python scripting?

assistant: # CollectionExport(bpy_struct)

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

*class* bpy.types.CollectionExport(*bpy_struct*)
:   export_properties
    :   Properties associated with the configured exporter

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

    filepath
    :   The file path used for exporting

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    is_open
    :   Whether the panel is expanded or closed

        Type:
        :   boolean, default False

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Curve
:   Standard geometry input.
    All non-curve components are ignored.

Profile Curve
:   If a profile curve is provided, it will be extruded along all splines.
    Otherwise the generated mesh will just be a chain of edges.

Scale
:   The scale used at each control point of the input curve to scale the profile curve.

Fill Caps
:   If the profile spline is cyclic, fill the ends of the generated mesh with n-gons.
    The resulting mesh is [Manifold](../../../../glossary/index.html#term-Manifold), the two new faces for each spline are
    simply connected to existing edges.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Next Edge Index
:   The index of the neighboring edge in the face, in the direction of increasing face corner indices.

Previous Edge Index
:   The index of the neighboring edge in the face, in the direction of decreasing face corner indices.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`MovieTracking.reconstruction`](bpy.types.MovieTracking.html#bpy.types.MovieTracking.reconstruction "bpy.types.MovieTracking.reconstruction") | - [`MovieTrackingObject.reconstruction`](bpy.types.MovieTrackingObject.html#bpy.types.MovieTrackingObject.reconstruction "bpy.types.MovieTrackingObject.reconstruction") |
user: How do I use Socket Syncing in Blender? Include parameters, examples, warnings and best practices.

assistant: Bundles use socket names to match their inputs and outputs.
If two bundle nodes are connected but have mismatched signatures,
Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never updated automatically to avoid overwriting data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Explain Bone Collections in complete detail according to the official Blender documentation.

assistant: This list shows the [bone collections](../../../../glossary/index.xhtml#term-Bone-Collection) the bone is assigned to.
Press the eye icon to show or hide the entire bone collection.
Press the star icon to show only this bone collection, and others also marked as ‘solo’
Press the X icon to remove the bone from that particular collection.

To assign the bone to other bone collections, either use the `M` or `Shift`-`M` shortcuts
(see [Moving Bones Between Collections](../../properties/bone_collections.xhtml#moving-bones-between-collections))
or go to the [Armature properties panel](../../properties/bone_collections.xhtml#bpy-types-bonecollection).
user: Explain Set Shade Smooth Node in complete detail according to the official Blender documentation.

assistant: # Set Shade Smooth Node

[image reference removed]

The *Set Shade Smooth* node controls whether the mesh’s faces look smooth in the viewport and renders.
The smooth status of both edges and faces can be controlled, corresponding to the `sharp_edge` and
`sharp_face` attributes.
The input node for this data is the [Is Face Smooth Node](../read/is_face_smooth.xhtml).
user: What is Mirror and how is it used in Blender Python scripting?

assistant: Mirrors the selected keyframes across a reference point.

By Times over Current Frame
:   Mirror horizontally across the current frame.

By Values over Cursor Value
:   Mirror vertically across the 2D Cursor’s value.

By Times over Zero Time
:   Mirror horizontally across frame 0.

By Values over Zero Value
:   Mirror vertically across value 0.

By Times over First Selected Marker
:   Mirror horizontally across the first selected marker.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`PreferencesFilePaths.asset_libraries`](bpy.types.PreferencesFilePaths.html#bpy.types.PreferencesFilePaths.asset_libraries "bpy.types.PreferencesFilePaths.asset_libraries") |  |
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`FreestyleLineStyle.geometry_modifiers`](bpy.types.FreestyleLineStyle.html#bpy.types.FreestyleLineStyle.geometry_modifiers "bpy.types.FreestyleLineStyle.geometry_modifiers") - [`LineStyleGeometryModifiers.new`](bpy.types.LineStyleGeometryModifiers.html#bpy.types.LineStyleGeometryModifiers.new "bpy.types.LineStyleGeometryModifiers.new") | - [`LineStyleGeometryModifiers.remove`](bpy.types.LineStyleGeometryModifiers.html#bpy.types.LineStyleGeometryModifiers.remove "bpy.types.LineStyleGeometryModifiers.remove") |
user: Provide the full official documentation entry for Info Editor, preserving all code examples.

assistant: # Info Editor

The Info editor logs the executed operators as well as errors, warnings,
and informational messages. You can select an entry by clicking it,
optionally holding `Shift` to add it to the existing selection.

[image reference removed]

Info Editor.
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Strip.name`](bpy.types.Strip.html#bpy.types.Strip.name "bpy.types.Strip.name") - [`Strip.type`](bpy.types.Strip.html#bpy.types.Strip.type "bpy.types.Strip.type") - [`Strip.select`](bpy.types.Strip.html#bpy.types.Strip.select "bpy.types.Strip.select") - [`Strip.select_left_handle`](bpy.types.Strip.html#bpy.types.Strip.select_left_handle "bpy.types.Strip.select_left_handle") - [`Strip.select_right_handle`](bpy.types.Strip.html#bpy.types.Strip.select_right_handle "bpy.types.Strip.select_right_handle") - [`Strip.mute`](bpy.types.Strip.html#bpy.types.Strip.mute "bpy.types.Strip.mute") - [`Strip.lock`](bpy.types.Strip.html#bpy.types.Strip.lock "bpy.types.Strip.lock") - [`Strip.frame_final_duration`](bpy.types.Strip.html#bpy.types.Strip.frame_final_duration "bpy.types.Strip.frame_final_duration") - [`Strip.frame_duration`](bpy.types.Strip.html#bpy.types.Strip.frame_duration "bpy.types.Strip.frame_duration") - [`Strip.frame_start`](bpy.types.Strip.html#bpy.types.Strip.frame_start "bpy.types.Strip.frame_start") - [`Strip.frame_final_start`](bpy.types.Strip.html#bpy.types.Strip.frame_final_start "bpy.types.Strip.frame_final_start") | - [`Strip.frame_final_end`](bpy.types.Strip.html#bpy.types.Strip.frame_final_end "bpy.types.Strip.frame_final_end") - [`Strip.frame_offset_start`](bpy.types.Strip.html#bpy.types.Strip.frame_offset_start "bpy.types.Strip.frame_offset_start") - [`Strip.frame_offset_end`](bpy.types.Strip.html#bpy.types.Strip.frame_offset_end "bpy.types.Strip.frame_offset_end") - [`Strip.channel`](bpy.types.Strip.html#bpy.types.Strip.channel "bpy.types.Strip.channel") - [`Strip.use_linear_modifiers`](bpy.types.Strip.html#bpy.types.Strip.use_linear_modifiers "bpy.types.Strip.use_linear_modifiers") - [`Strip.blend_type`](bpy.types.Strip.html#bpy.types.Strip.blend_type "bpy.types.Strip.blend_type") - [`Strip.blend_alpha`](bpy.types.Strip.html#bpy.types.Strip.blend_alpha "bpy.types.Strip.blend_alpha") - [`Strip.effect_fader`](bpy.types.Strip.html#bpy.types.Strip.effect_fader "bpy.types.Strip.effect_fader") - [`Strip.use_default_fade`](bpy.types.Strip.html#bpy.types.Strip.use_default_fade "bpy.types.Strip.use_default_fade") - [`Strip.color_tag`](bpy.types.Strip.html#bpy.types.Strip.color_tag "bpy.types.Strip.color_tag") - [`Strip.modifiers`](bpy.types.Strip.html#bpy.types.Strip.modifiers "bpy.types.Strip.modifiers") - [`Strip.show_retiming_keys`](bpy.types.Strip.html#bpy.types.Strip.show_retiming_keys "bpy.types.Strip.show_retiming_keys") |
user: Give a detailed overview of Color Ramp Widget: syntax, arguments, return values, common patterns.

assistant: # Color Ramp Widget

*Color Ramps* specify a color gradient based on color stops. Each stop has a position and a color.
The gradient is then calculated as the interpolation between these stops using the chosen
interpolation method.

[image reference removed]

Color ramp.
user: Explain Stiffness in complete detail according to the official Blender documentation.

assistant: To show the effect of the Stiffness setting, we will drop two cubes onto a plane
(see [Collisions](../collision.xhtml)). The blue cube uses quads,
while the red one uses triangles. Both cubes have their Goal setting disabled.

If *Stiffness* is disabled, the quad-only cube will collapse completely,
while the tri cube only temporarily deforms from the impact:

Without Stiffness.

|  |  |  |
| --- | --- | --- |
| ../../../_images/physics_soft-body_forces_interior_quadvstri-sb-001.png   Frame 1. | ../../../_images/physics_soft-body_forces_interior_quadvstri-sb-036.png   Frame 36. | ../../../_images/physics_soft-body_forces_interior_quadvstri-sb-401.png   Frame 401. |

If *Stiffness* is enabled, the quad cube maintains its shape as well thanks to the
extra springs:

With Stiffness.

|  |  |  |
| --- | --- | --- |
| ../../../_images/physics_soft-body_forces_interior_quadvstri-sb-001.png   Frame 1. | ../../../_images/physics_soft-body_forces_interior_quadvstri-sb-sq-036.png   Frame 36. | ../../../_images/physics_soft-body_forces_interior_quadvstri-sb-sq-401.png   Frame 401. |
user: Describe Propagate to Shapes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Propagate to Shapes

The *Propagate to Shapes* operator applies the current positions of the selected vertices
to all other [shape keys](../../../../animation/shape_keys/index.html) on the object.
This allows edits made in *Edit Mode* to be consistently transferred across every shape key.

This is useful for:

- Correcting vertex positions that should be the same in all shape keys.
- Fixing topology issues or small modeling mistakes without manually editing each shape key.
- Ensuring consistent base structure across shape key variations.
user: Provide the full official documentation entry for SpaceNodeOverlay(bpy_struct), preserving all code examples.

assistant: # SpaceNodeOverlay(bpy_struct)

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

*class* bpy.types.SpaceNodeOverlay(*bpy_struct*)
:   Settings for display of overlays in the Node Editor

    preview_shape
    :   Preview shape used by the node previews

        - `FLAT`
          Flat – Use the default flat previews.
        - `3D`
          3D – Use the material preview scene for the node previews.

        Type:
        :   enum in [`'FLAT'`, `'3D'`], default `'FLAT'`

    show_context_path
    :   Display breadcrumbs for the editor’s context

        Type:
        :   boolean, default True

    show_named_attributes
    :   Show when nodes are using named attributes

        Type:
        :   boolean, default True

    show_overlays
    :   Display overlays like colored or dashed wires

        Type:
        :   boolean, default True

    show_previews
    :   Display each node’s preview if node is toggled

        Type:
        :   boolean, default False

    show_reroute_auto_labels
    :   Label reroute nodes based on the label of connected reroute nodes

        Type:
        :   boolean, default False

    show_timing
    :   Display each node’s last execution time

        Type:
        :   boolean, default False

    show_wire_color
    :   Color node links based on their connected sockets

        Type:
        :   boolean, default True

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

assistant: Mirror around the individual origins.

|  |  |
| --- | --- |
| <../../../_images/modeling_meshes_editing_mesh_mirror_cursor-before.png>   Mesh before mirroring. | <../../../_images/modeling_meshes_editing_mesh_mirror_individual-after.png>   Mesh after mirroring along the X axis. |

The next example shows mirroring around the *3D Cursor*, with the orientation set to *Local*:

Mirror around the 3D Cursor.

|  |  |
| --- | --- |
| <../../../_images/modeling_meshes_editing_mesh_mirror_cursor-before.png>   Mesh before mirroring. | <../../../_images/modeling_meshes_editing_mesh_mirror_cursor-after.png>   Mesh after mirroring along the X axis using the 3D Cursor as the pivot point. |
user: Provide the full official documentation entry for RepeatZoneViewerPathElem(ViewerPathElem), preserving all code examples.

assistant: # RepeatZoneViewerPathElem(ViewerPathElem)

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

*class* bpy.types.RepeatZoneViewerPathElem(*ViewerPathElem*)
:   repeat_output_node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Straighten Hair Curves in complete detail according to the official Blender documentation.

assistant: # Straighten Hair Curves

The *Straighten Hair Curves* node aligns the points of each hair curve along a straight line
between its root and tip.
This can be used to relax curly or noisy hair, create stylized grooms, or prepare curves
for further deformation or simulation.
user: Describe Bpy.Ops.Cachefile from the Blender manual or Python API, including usage steps and snippets.

assistant: optional ) ) – Filter Alembic files filter_usd ( boolean , ( optional ) ) – Filter USD files filter_obj ( boolean , ( optional ) ) – Filter OBJ files filter_volume ( boolean , ( optional ) ) – Filter OpenVDB volume files filter_folder ( boolean , ( optional ) ) – Filter folders filter_blenlib ( boolean , ( optional ) ) – Filter Blender IDs filemode ( int in [ 1 , 9 ] , ( optional ) ) – File Browser Mode, The setting for the file browser mode to load a .blend file, a library or a special file relative_path ( boolean , ( optional ) ) – Relative Path, Select the file relative to the blend file display_type (enum in [ 'DEFAULT' , 'LIST_VERTICAL' , 'LIST_HORIZONTAL' , 'THUMBNAIL' ], (optional)) – Display Type DEFAULT Default – Automatically determine display type for files. LIST_VERTICAL Short List – Display files as short list. LIST_HORIZONTAL Long List – Display files as a detailed list. THUMBNAIL Thumbnails – Display files as thumbnails. sort_method ( enum in [ ] , ( optional ) ) – File sorting mode bpy.ops.cachefile. reload ( ) ¶ Update objects paths list with new data from the archive Next Camera Operators Previous Buttons Operators Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Cachefile Operators layer_add() layer_move() layer_remove() open() reload()
user: Show practical ways to work with Icosphere in a Blender add-on or script – include code.

assistant: An icosphere is a sphere built from equilateral triangles
and has a more uniform distribution of vertices compared to a UV sphere.
This makes it ideal for sculpting, simulations, or applications where topological regularity is important.

It is created by recursively subdividing the faces of an icosahedron, which is a polyhedron with 20 triangular faces.

Subdivisions
:   Number of recursive subdivision steps.
    Each step splits every triangle into four new triangles, increasing the mesh resolution exponentially.

    - Subdivision Level 1 creates the base icosahedron.
    - Higher levels smooth the surface and increase vertex count.

Radius
:   Distance from the center to the outer surface of the sphere.
user: What is GeometryNodeSwitch(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSwitch(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.GeometryNodeSwitch(*GeometryNode*)
:   Switch between two inputs

    input_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 `'GEOMETRY'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Selecting Curve Elements in Blender? Include parameters, examples, warnings and best practices.

assistant: # Selecting Curve Elements

Hair curves, while similar to regular curves are a bit different and have their own selection tools.
Many of these match their regular curve tools but are implemented differently
All hair curve selection operators are documented below for completeness.

These selection operators work in both Sculpt and Edit modes.
user: Describe wmOwnerID(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # wmOwnerID(bpy_struct)

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

*class* bpy.types.wmOwnerID(*bpy_struct*)
:   name
    :   Type:
        :   string, default “”, (never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type