PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: ### Activation and Deactivation

Use `Shift`-`Ctrl`-`LMB` on any node or socket to connect it to the active viewer.

In the viewport *View* menu, the *Viewer Node* option can toggle the visibility of
all viewer visualizations, allowing you to compare the evaluated result with the final object output.

### Keyboard Shortcuts

The Viewer node system provides shortcuts to quickly assign and activate viewers:

- **Assign Shortcut** (`Ctrl`-`1`, `Ctrl`-`2`, etc.):
  Select a viewer node and press a shortcut to assign it to that number.
  The assigned number appears in the upper-right corner of the node.
- **Activate Viewer** (`1`, `2`, etc.):
  Press the assigned number key to activate the corresponding viewer node.

### Viewing Single Socket Values

In addition to using the Viewer node, single-value sockets can display their evaluated values
directly within the node editor.
When enabled, the current evaluated value is shown beside the socket input, making it easy
to inspect and debug data flow without connecting a Viewer node.

This feature is available for scalar and small data types, such as *Float*, *Integer*, *Boolean*, or *Vector* sockets.
The displayed value updates interactively as the node tree evaluates or parameters change.

### Attribute Field Visualization

When the Viewer node has both a *Geometry* and a field input connected,
the values can be visualized directly in the 3D Viewport via the
[Viewer Overlay](../../../editors/3dview/display/overlays.xhtml#dview-overlays-view-node).

The attribute’s [domain](../attributes_reference.xhtml#attribute-domains) is determined automatically when possible.
Otherwise, the Viewer defaults to the *Face Corner* domain for meshes and the *Point* domain for curves.
The domain can also be set manually from the node’s properties.

In the Spreadsheet Editor, only the columns for attributes corresponding to the currently selected domain are shown.

### Pinning

The Viewer node can be *pinned* in the Spreadsheet Editor to keep its data visible even when it becomes inactive.
When pinned, the Spreadsheet continues showing the data from the pinned Viewer node,
regardless of changes to the active object or node selection.
user: How do I use Data-Block Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: # Data-Block Menu

Lets you select a [Data-Block](../../../files/data_blocks.html) (such as a material)
in order to link it to something else (such as an object).

[image reference removed]

A data-block menu with a search field.

Type
:   Shows an icon indicating the data-block type. Clicking the image or the down arrow opens the popup menu.
    Dragging the image lets you apply the data-block to something else. (For example, you can drag a
    material onto an object in the 3D Viewport to [assign](../../../render/materials/assignment.html) it.
    Dragging onto [Data ID](#ui-data-id) fields is also possible.)

    List
    :   A list of data-blocks available in the current blend-file, or a link to select an item from.
        The menu may show a preview besides the items and
        a search field to search the items in the list by name.

Name
:   Displays, and allows [editing](../../../files/data_blocks.html#data-system-datablock-name-and-rename) of, the name of the selected
    data-block.

User Count
:   Displays the number of [users](../../../glossary/index.html#term-Data-User) of the data (if there’s more than one user).
    Clicking it will create a single-user copy.

    As an example, if three separate objects referenced the same material, the material’s user count would be 3.
    Changing the material would affect all three objects. If you now selected an object and clicked the user count,
    the object would receive its very own copy of the material, which can be modified independently of the original
    that’s still used by the other two.

Fake User (shield icon)
:   If a data-block has no [real users](../../../glossary/index.html#term-Real-User), it’ll normally be cleaned up
    (deleted) when saving the blend-file. To prevent this, you can give it a fake user;
    that way, it’s guaranteed to “survive.” Data-blocks with a fake user have an “F”
    prefix in the drop-down list.

    The [Outliner](../../../editors/outliner/introduction.html) can show an overview of all data-blocks
    without real users in the blend-file. Simply change its Display Mode to Orphan Data.

New/Add (files icon)
:   Creates a new data-block (or duplicates the current one) and selects it.

Open File (folder icon)
:   Opens the [File Browser](../../../editors/file_browser.html), for importing an image for example.

Unpack File (bin icon)
:   [Unpack](../../../files/blend/packed_data.html#pack-unpack-data) the file packed into the current blend-file to an external one.

(Unlink Data-block)
:   Clears the link. `Shift`-`LMB` to set the users to zero
    allowing the data to be fully deleted from the blend-file.

Sometimes there is a [list](list_view.html#ui-list-view) of applied data-blocks
(such as a list of materials used on the object).
user: Describe Interpolated from the Blender manual or Python API, including usage steps and snippets.

assistant: Virtual Parents
:   Relative amount of virtual parents.

Long Hair
:   Calculate children that suit long hair well.

### Parting

Parting
:   Creates parting in the children based on parent strands.

Min/Max
:   The minimum/maximum root to tip angle (tip distance/root distance for long hair).
user: Give a detailed overview of Common Modifier Options: syntax, arguments, return values, common patterns.

assistant: # Common Modifier Options

Some options are commonly used by many modifiers, and share the same behavior across all of those.
In particular, many offer ways to precisely mask and weight their effect on a vertex basis
(using either vertex groups and/or textures).
user: What is Edit Mode Tools and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| `Ctrl`-`E` | [Extrude](../../modeling/meshes/editing/mesh/extrude.xhtml) |
| `Ctrl`-`B` | [Bevel](../../modeling/meshes/editing/edge/bevel.xhtml) |
| `I` | [Inset](../../modeling/meshes/editing/face/inset_faces.xhtml) |
| `K` | [Knife](../../modeling/meshes/editing/mesh/knife_topology_tool.xhtml) |
| `Alt`-`C` | [Loop Cut](../../modeling/meshes/editing/edge/loopcut_slide.xhtml) |
user: How do I use LimitDistanceConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LimitDistanceConstraint(Constraint)

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

*class* bpy.types.LimitDistanceConstraint(*Constraint*)
:   Limit the distance from target object

    distance
    :   Radius of limiting sphere

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

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    limit_mode
    :   Distances in relation to sphere of influence to allow

        - `LIMITDIST_INSIDE`
          Inside – The object is constrained inside a virtual sphere around the target object, with a radius defined by the limit distance.
        - `LIMITDIST_OUTSIDE`
          Outside – The object is constrained outside a virtual sphere around the target object, with a radius defined by the limit distance.
        - `LIMITDIST_ONSURFACE`
          On Surface – The object is constrained on the surface of a virtual sphere around the target object, with a radius defined by the limit distance.

        Type:
        :   enum in [`'LIMITDIST_INSIDE'`, `'LIMITDIST_OUTSIDE'`, `'LIMITDIST_ONSURFACE'`], default `'LIMITDIST_INSIDE'`

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_transform_limit
    :   Transforms are affected by this constraint as well

        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: Give a detailed overview of Basic Setup: syntax, arguments, return values, common patterns.

assistant: The Spline IK Constraint is not strictly an *Inverse Kinematics* method (i.e. IK Constraint),
but rather a *Forward Kinematics* method (i.e. normal bone posing). However,
it still shares some characteristics of the IK Constraint,
such as operating on multiple bones, not being usable for Objects,
and being evaluated after all other constraints have been evaluated. It should be noted that
if a Standard IK chain and a Spline IK chain both affect a bone at the same time the Standard
IK chain takes priority. Such setups are best avoided though,
since the results may be difficult to control.

To setup Spline IK,
it is necessary to have a chain of connected bones and a curve to constrain these bones to:

1. With the last bone in the chain selected,
   add a [Spline IK](../../../../constraints/tracking/spline_ik.xhtml)
   Constraint from the Bone Constraints tab in the Properties.
2. Set the *Chain Length* setting to the number of bones in the chain
   (starting from and including the selected bone) that should be influenced by the curve.
3. Finally, set the *Target* field to the curve that should control the curve.

Congratulations, the bone chain is now controlled by the curve.
user: Explain CompositorNodeTonemap(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeTonemap(CompositorNode)

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

*class* bpy.types.CompositorNodeTonemap(*CompositorNode*)
:   Map one set of colors to another in order to approximate the appearance of high dynamic range

    *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")

    update()

    *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 Outputs, preserving all code examples.

assistant: Curve
:   Poly spline generated from the inputs.

Center
:   The center of the arc described by the three points. *Points* mode only.

Normal
:   The normal direction of the plane described by the three points,
    pointing towards the positive Z axis. *Points* mode only.

Radius
:   The radius of the arc described by the three points. *Points* mode only.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: 1. Shift-select the object to be parented (the child object).
2. Select the parent mesh object and enter *Edit Mode*.
3. Select **one or three** vertices that will define the parent relationship.
4. Press `Ctrl`-`P`
user: Describe Set Grease Pencil Depth Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Set Grease Pencil Depth Node

[image reference removed]

The *Set Grease Pencil Depth* node sets the Grease Pencil
[depth order](../../../../grease_pencil/properties/strokes.html#bpy-types-greasepencil-stroke-depth-order) to use.
user: What is FunctionNodeRotateRotation(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeRotateRotation(FunctionNode)

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

*class* bpy.types.FunctionNodeRotateRotation(*FunctionNode*)
:   Apply a secondary rotation to a given rotation value

    rotation_space
    :   Base orientation for the rotation

        - `GLOBAL`
          Global – Rotate the input rotation in global space.
        - `LOCAL`
          Local – Rotate the input rotation in its local space.

        Type:
        :   enum in [`'GLOBAL'`, `'LOCAL'`], default `'GLOBAL'`

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

assistant: # Region Type Items

WINDOW:
:   Window.

HEADER:
:   Header.

CHANNELS:
:   Channels.

TEMPORARY:
:   Temporary.

UI:
:   Sidebar.

TOOLS:
:   Tools.

TOOL_PROPS:
:   Tool Properties.

ASSET_SHELF:
:   Asset Shelf.

ASSET_SHELF_HEADER:
:   Asset Shelf Header.

PREVIEW:
:   Preview.

HUD:
:   Floating Region.

NAVIGATION_BAR:
:   Navigation Bar.

EXECUTE:
:   Execute Buttons.

FOOTER:
:   Footer.

TOOL_HEADER:
:   Tool Header.

XR:
:   XR.
user: What is Solve Camera/Object Motion and how is it used in Blender Python scripting?

assistant: The *Solve Camera/Object Motion* operator solves the motion of the camera or the
selected [tracked object](../sidebar/track/objects.xhtml),
using all tracks placed on the footage and two keyframes specified on this panel.
There are some requirements:

- There should be at least eight common tracks on the both of the selected keyframes.
- There should be noticeable parallax effects between these two keyframes.

If everything goes smoothly during the solve, the average reprojection error is reported to
the information space and to the Clip editor header. Reprojection error means the average
distance between reconstructed 3D position of tracks projected back to footage and
original position of tracks. Basically, reprojection error below 0.3 means accurate reprojection,
(0.3 - 3.0) means quite nice solving which still can be used.
Values above 3 means some tracks should be tracked more accurately,
or that values for focal length or distortion coefficients were set incorrectly.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Repeat Items
:   [List View](../../../interface/controls/templates/list_view.xhtml#ui-list-view) for adding, removing, reordering, and renaming the inputs of the zone.

    Socket Type
    :   The [data type](../attributes_reference.xhtml#attribute-data-types) of the selected input.

Inspection Index
:   The number of the iteration to show in [socket inspection](../inspection.xhtml#socket-inspection)
    and in the [Viewer Node](../output/viewer.xhtml).
user: Give a detailed overview of Bake Action: syntax, arguments, return values, common patterns.

assistant: The final motion of objects and bones depends not only on the keyframed animation,
but also on [F-Curve modifiers](../../graph_editor/fcurves/modifiers.xhtml),
[drivers](../../../animation/drivers/introduction.xhtml),
and [constraints](../../../animation/constraints/introduction.xhtml).
The *Bake Action* operator computes this final motion and creates a corresponding
keyframe on every scene frame.

This can be useful for adding deviation to a cyclic action like a [Walk Cycle](../../../glossary/index.xhtml#term-Walk-Cycle),
or to create a keyframe animation from drivers or constraints.

Start Frame
:   Start frame for baking.

End Frame
:   End frame for baking.

Frame Step
:   Number of frames to skip forward while baking each frame.

Only Selected Bones
:   Only key selected bones (Pose baking only).

Visual Keying
:   Keyframe from the final transformations (with constraints applied).

Clear Constraints
:   Remove all constraints from keyed object/bones, and do ‘visual’ keying.

Clear Parents
:   Bake animation onto the object then clear parents (objects only).

Overwrite Current Action
:   Bake animation into the current action instead of creating a new one
    (useful for baking only part of bones in an armature).

Clean Curves
:   After baking curves, [remove redundant keys](../../graph_editor/fcurves/editing.xhtml#bpy-ops-graph-clean).

Bake Data
:   Which data transformations to bake.

    Pose:
    :   Bake bone transformations.

    Object:
    :   Bake object transformations.

Channels
:   Which channels to bake.

    Location:
    :   Bake location channels.

    Rotation:
    :   Bake rotation channels.

    Scale:
    :   Bake scale channels.

    B-Bone:
    :   Bake [B-Bone](../../../animation/armatures/bones/properties/bendy_bones.xhtml) channels.

    Custom Properties:
    :   Bake custom properties.
user: Give a detailed overview of Chat: syntax, arguments, return values, common patterns.

assistant: For real-time discussion, we have [chat.blender.org](https://chat.blender.org) which uses [Blender ID](https://id.blender.org) for authentication.

You can join these channels:

- [#general](https://chat.blender.org/#/room/#general:blender.org)
  For general chat with the community.
- [#blender-coders](https://chat.blender.org/#/room/#blender-coders:blender.org)
  For developers to discuss Blender development.
- [#python](https://chat.blender.org/#/room/#python:blender.org)
  For support for developers using the Python API.
- [#docs](https://chat.blender.org/#/room/#docs:blender.org)
  For discussion related to Blender’s documentation.
- [#translations](https://chat.blender.org/#/room/#translations:blender.org)
  For discussion related to translating Blender and its documentation.
user: Describe Crease Angle from the Blender manual or Python API, including usage steps and snippets.

assistant: # Crease Angle

A modifier based on the Crease Angle (angle between two adjacent faces).
If a stroke segment does not lie on a crease (i.e. the edge does not have the *Crease Angle nature*),
its properties are not touched by the modifier.

Angle Min, Max
:   The range of input values to the mapping.
    Out-of-range crease angle values will be clamped by
    the Min and Max angles and their corresponding property values.

[image reference removed]

Crease Angle modifier example by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_crease_angle.blend)).
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The Preview mode shows how the final edited video will look like. It also offers tools for
moving, rotating, and scaling images, as well as scopes for analyzing color distribution.

[image reference removed]

Preview mode of the Video Sequencer.

You can pan around the view with `MMB` and zoom with `Wheel` or `NumpadPlus`/
`NumpadMinus`. Alternatively, you can use the gizmos.

Pressing `Home` resets the view, maximizing the size of the preview within the editor’s area.
user: Show practical ways to work with FModifierEnvelopeControlPoints(bpy_struct) in a Blender add-on or script – include code.

assistant: # FModifierEnvelopeControlPoints(bpy_struct)

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

*class* bpy.types.FModifierEnvelopeControlPoints(*bpy_struct*)
:   Control points defining the shape of the envelope

    add(*frame*)
    :   Add a control point to a FModifierEnvelope

        Parameters:
        :   **frame** (*float in* *[**-inf**,* *inf**]*) – Frame to add this control-point

        Returns:
        :   Newly created control-point

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

    remove(*point*)
    :   Remove a control-point from an FModifierEnvelope

        Parameters:
        :   **point** ([`FModifierEnvelopeControlPoint`](bpy.types.FModifierEnvelopeControlPoint.html#bpy.types.FModifierEnvelopeControlPoint "bpy.types.FModifierEnvelopeControlPoint"), (never None)) – Control-point to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [Move](../../scene_layout/object/editing/transform/move.html) `G`
:   Change the location of control points. Control points can also be moved with `LMB`.
    The whole spline can be moved by dragging the center dot with `LMB`.

[Rotate](../../scene_layout/object/editing/transform/rotate.html) `R`
:   Change the location of control points by rotating about a pivot point.

[Scale](../../scene_layout/object/editing/transform/scale.html) `S`
:   Change the location of control points by expanding the distance between points.

[To Sphere](../../modeling/meshes/editing/mesh/transform/to_sphere.html) `Shift`-`Alt`-`S`
:   Morphs the control points to the shape of a circle.

[Shear](../../modeling/meshes/editing/mesh/transform/shear.html) `Shift`-`Ctrl`-`Alt`-`S`
:   Shifts control points along a defined axis so parallel control points move past one another.

[Push/Pull](../../modeling/meshes/editing/mesh/transform/push_pull.html)
:   Moves the control points closer together (Push) or further apart (Pull).

Scale Feather `Alt`-`S`
:   Will scale the feather size.
user: Show practical ways to work with Primitives in a Blender add-on or script – include code.

assistant: [image reference removed]

Empty Display Types.

### Plain Axes

Displays as six lines, initially with one pointing in each of the +X, -X, +Y, -Y, +Z, and -Z axis directions.

### Arrows

Displays as arrows, initially pointing in the positive X, Y, and Z axis directions, each with a label.

### Single Arrow

Displays as a single arrow, initially pointing in the +Z axis direction.

### Circle

Displays as a circle initially in the XZ plane.

### Cube

Displays as a cube, initially aligned to the XYZ axes.

### Sphere

Displays as an implied sphere defined by three circles.
Initially, the circles are aligned, one each, to the X, Y, and Z axes.

### Cone

Displays as a cone, initially pointing in the +Y axis direction.

### Image

Empties can display images. This can be used to create reference images,
including blueprints or character sheets to model from.
The image is displayed regardless of the 3D display mode.

Empty Displays settings can be accessed from Properties ‣ Object Data ‣ Empty panel.

Offset X, Y
:   Offset the image origin
    (where 1.0 represents the width/height of the image).

    X=0.5, Y=0.5:
    :   Object origin at image center.

    X=0.0, Y=0.0:
    :   Object origin at image bottom, left.

    X=1.0, Y=1.0:
    :   Object origin at image top, right.

Depth
:   Default:
    :   Use normal depth behavior.

    Front:
    :   Always display on top of other objects.

    Back:
    :   Always display behind of other objects.

Side
:   Both:
    :   Display both the front and back of the empty.

    Front:
    :   Only display the front of the image.

    Back:
    :   Only display the back of the image.

Show in
:   Orthographic
    :   Show in orthographic view.

    Perspective
    :   Show in perspective view.

    Only Axis Aligned
    :   Only displays the image contents when the view is aligned with the object’s local axis.

Opacity
:   Blends the image with the background. The value slider adjusts the opacity of the image,
    changing how much of the image is blended with the background.
user: Explain Curve Operators in complete detail according to the official Blender documentation.

assistant: vide selected segments

    Parameters:
    :   **number_cuts** (*int in* *[**1**,* *1000**]**,* *(**optional**)*) – Number of Cuts

bpy.ops.curve.switch_direction()
:   Switch direction of selected splines

bpy.ops.curve.tilt_clear()
:   Clear the tilt of selected control points

bpy.ops.curve.vertex_add(*\**, *location=(0.0, 0.0, 0.0)*)
:   Add a new control point (linked to only selected end-curve one, if any)

    Parameters:
    :   **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (optional)) – Location, Location to add new vertex at
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 in certain operations.
For instance, the *Scale* input is only available in the *Scale* operator.

Vector
:   Input vector \(A = \begin{pmatrix} A_x \\ A_y \\ A_z \end{pmatrix}\).

Vector
:   Input vector \(B = \begin{pmatrix} B_x \\ B_y \\ B_z \end{pmatrix}\).

Scale
:   Input Scale \(s\).
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

The movement of particles may be controlled in a multitude of ways.
Here we will discuss only the particle physics in the narrower sense, i.e.
the settings in the Physics panel.

Additional ways of moving particles are:

- By soft body animation (only for Hair particle systems).
- By force fields and along curves.
- By lattices.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Keyboard Shortcuts

Viewer node provide a quick way to toggle between different viewer nodes while compositing using keyboard shortcuts,
improving workflow efficiency when comparing outputs.

- **Assign Shortcut** (`Ctrl`-`1`, `Ctrl`-`2`, etc.):
  Select a node and press a shortcut to assign it. If no Viewer node is attached, one is created and activated.
  The number will be shown in the upper right part of the node to identify which shortcut is assigned.
- **Activate Node** (`1`, `2`, etc.):
  Press the assigned number key to activate the node’s Viewer output.

### Using the Image Editor

The Viewer node allows results to be displayed in the Image Editor.
The image is facilitated in the header by selecting *Viewer Node* in the linked *Image* data-block menu.
The Image Editor will display the image from the currently selected Viewer node.

To save the image being viewed,
use Image ‣ Save As…, `Alt`-`S` to save the image to a file.

The Image Editor also has three additional options in its header to view Images with or
without Alpha, or to view the Alpha or Z itself.
Click and holding the mouse in the Image displayed allows you to sample the values.
user: Provide the full official documentation entry for Brush Settings, preserving all code examples.

assistant: # Brush Settings

Material
:   Data-block selector for the [material](../../../materials/index.xhtml).
    Except for the *Erase* tool of course.

    / Pin Material
    :   Pin the material to the brush.

        The final appearance of the strokes is a combination of the brush and material used,
        binding the material to the brush gives more control and avoids a lack of coordination between the two.
user: How do I use Bpy.Types.Arealight in Blender? Include parameters, examples, warnings and best practices.

assistant: ow_maximum_resolution AreaLight.shadow_soft_size AreaLight.shape AreaLight.size AreaLight.size_y AreaLight.spread AreaLight.use_absolute_resolution AreaLight.use_shadow_jitter AreaLight.inline_shader_nodes() AreaLight.bl_rna_get_subclass() AreaLight.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Geometry in a Blender add-on or script – include code.

assistant: Display UVs
:   Display selected and active object’s UVs.

UV Face Opacity
:   Opacity of faces. Useful to differentiate between UV islands. Can also be reduced when
    texture painting to prevent faces from tinting the texture’s colors.
user: Show practical ways to work with Object Node in a Blender add-on or script – include code.

assistant: # Object Node

[image reference removed]

The *Object* input node outputs a single object. It can be connected to other object sockets
to make using the same object in multiple places more convenient.
user: Describe Closure from the Blender manual or Python API, including usage steps and snippets.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Show practical ways to work with Calligraphy in a Blender add-on or script – include code.

assistant: # Calligraphy

The *Calligraphy* modifier mimics some broad and flat pens for calligraphy.
It generates different thickness based on the orientation of the stroke.

Orientation
:   The angle (orientation) of the virtual drawing tool, from the vertical axis of the picture.
    For example, an angle of 0.0 mimics a pen aligned with the vertical axis.
    Hence, the thickest strokes will be the vertical ones i.e. stroke’s direction is aligned with the angle, and
    the thinnest will be the horizontal ones i.e. stroke’s direction is perpendicular to the angle.

[image reference removed]

Calligraphy modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_Calligraphy.zip)).
user: Show practical ways to work with Editing in a Blender add-on or script – include code.

assistant: Flip (Distortion Free)
:   Mirrors the vertices displacement from their base position.

    U, V, W

Make Regular
:   Resets the whole lattice to a regular grid, where the cells are scaled to one cubic unit.
user: What is API Reference Usage and how is it used in Blender Python scripting?

assistant: # API Reference Usage

Blender has many interlinking data types which have an auto-generated reference API which often has the information
you need to write a script, but can be difficult to use.
This document is designed to help you understand how to use the reference API.
user: Provide the full official documentation entry for Selecting, preserving all code examples.

assistant: # Selecting

By default, Blender uses `LMB` to select items.
This can be changed to `RMB` in the [Preferences](../editors/preferences/keymap.html).

Blender has several selection tools that can be used across the different editors.

Most selection tools come in two variants, where one variant is available in the Toolbar
and the other in the *Select* menu. While the variants’ names are almost identical
(such as *Select Box* in the Toolbar versus *Box Select* in the menu),
the way they work is a bit different. New users coming from other applications
will find the Toolbar variants to be the most familiar.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Input is Mesh Plane. First [Subdivide Mesh Node](../mesh/operations/subdivide_mesh.xhtml) add some
faces for capture color with [Random Value Node](../utilities/random_value.xhtml)
used as hue in [Combine Color Node](../color/combine_color.xhtml) on this.
Now second [Subdivide Mesh Node](../mesh/operations/subdivide_mesh.xhtml) split each face on a lot of new.
Each one new duplicates original attribute.
Blur Attribute node mixes all attributes for each face. Due to this, the result is smoothed.
user: Explain Error Messages in complete detail according to the official Blender documentation.

assistant: In case of problems, be sure to install the official graphics drivers from the GPU manufacturers website,
or through the package manager on Linux.
The graphics drivers provided by the computer manufacturer can sometimes be outdated or incomplete.

### Error: Out of memory

This usually means there is not enough memory to store the scene for use by the GPU.

### The NVIDIA OpenGL driver lost connection with the display driver

If a GPU is used for both display and rendering,
Windows has a limit on the time the GPU can do render computations.
If you have a particularly heavy scene, Cycles can take up too much GPU time.
Reducing Tile Size in the Performance panel may alleviate the issue,
but the only real solution is to use separate graphics cards for display and rendering.

Another solution can be to increase the time-out,
although this will make the user interface less responsive when rendering heavy scenes.
[Learn More Here](https://learn.microsoft.com/en-us/windows-hardware/drivers/display/timeout-detection-and-recovery).

### Unsupported GNU version

On Linux, depending on your GCC version you might get this error.
See the [NVIDIA CUDA Installation Guide for Linux](https://docs.nvidia.com/cuda/archive/10.2/cuda-installation-guide-linux/index.html)
for a list of supported GCC versions. There are two possible solutions to this error:

Use an alternate compiler
:   If you have an older GCC installed that is compatible with the installed CUDA toolkit version,
    then you can use it instead of the default compiler.
    This is done by setting the `CYCLES_CUDA_EXTRA_CFLAGS` environment variable when starting Blender.

    Launch Blender from the command line as follows:

    ```
    CYCLES_CUDA_EXTRA_CFLAGS="-ccbin gcc-x.x" blender
    ```

    (Substitute the name or path of the compatible GCC compiler).

Remove compatibility checks
:   If the above is unsuccessful, delete the following line in
    `/usr/local/cuda/include/host_config.h`:

    ```
    #error -- unsupported GNU version! gcc x.x and up are not supported!
    ```

    This will allow Cycles to successfully compile the CUDA rendering kernel the first time it
    attempts to use your GPU for rendering. Once the kernel is built successfully, you can
    launch Blender as you normally would and the CUDA kernel will still be used for rendering.

### CUDA Error: Kernel compilation failed

This error may happen if you have a new NVIDIA graphics card that is not yet supported by
the Blender version and CUDA toolkit you have installed.
In this case Blender may try to dynamically build a kernel for your graphics card and fail.

In this case you can:

1. Check if the latest Blender version
   (official or [experimental builds](https://builder.blender.org/download/))
   supports your graphics card.
2. If you build Blender yourself, try to download and install a newer CUDA developer toolkit.

Normally users do not need to install the CUDA toolkit as Blender comes with precompiled kernels.
user: Provide the full official documentation entry for Nla Mode Blend Items, preserving all code examples.

assistant: # Nla Mode Blend Items

REPLACE:
:   Replace.

    The strip values replace the accumulated results by amount specified by influence.

COMBINE:
:   Combine.

    The strip values are combined with accumulated results by appropriately using addition, multiplication, or quaternion math, based on channel type.

---

ADD:
:   Add.

    Weighted result of strip is added to the accumulated results.

SUBTRACT:
:   Subtract.

    Weighted result of strip is removed from the accumulated results.

MULTIPLY:
:   Multiply.

    Weighted result of strip is multiplied with the accumulated results.
user: Explain GeometryNodeSampleGrid(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeSampleGrid(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.GeometryNodeSampleGrid(*GeometryNode*)
:   Retrieve values from the specified volume grid

    data_type
    :   Node socket data type

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe MaskParent(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MaskParent(bpy_struct)

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

*class* bpy.types.MaskParent(*bpy_struct*)
:   Parenting settings for masking element

    id
    :   ID-block to which masking element would be parented to or to its property

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

    id_type
    :   Type of ID-block that can be used

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

    parent
    :   Name of parent object in specified data-block to which parenting happens

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

    sub_parent
    :   Name of parent sub-object in specified data-block to which parenting happens

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

    type
    :   Parent Type

        Type:
        :   enum in [`'POINT_TRACK'`, `'PLANE_TRACK'`], default `'POINT_TRACK'`

    *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.MaskParent.type "bpy.types.MaskParent.type")
user: How do I use Interactive Region in Blender? Include parameters, examples, warnings and best practices.

assistant: The interactive region is the bottom half of the splash screen.

New File
:   Start a new project based on a template.

Recent Files
:   Your most recently opened blend-files. This gives quick and easy access to your recent projects.

Open
:   Allows opening an existing blend-file.

Recover Last Session
:   Blender will try to recover the last [session](../../glossary/index.html#term-Session) based on temporary files. See
    [Recovering Data](../../troubleshooting/recover.html).

What’s New
:   Open the latest release notes.

Donate to Blender
:   Open Blender’s [Development Fund](https://fund.blender.org/) website.
user: How do I use XrActionMapBinding(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # XrActionMapBinding(bpy_struct)

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

*class* bpy.types.XrActionMapBinding(*bpy_struct*)
:   Binding in an XR action map item

    axis0_region
    :   Action execution region for the first input axis

        - `ANY`
          Any – Use any axis region for operator execution.
        - `POSITIVE`
          Positive – Use positive axis region only for operator execution.
        - `NEGATIVE`
          Negative – Use negative axis region only for operator execution.

        Type:
        :   enum in [`'ANY'`, `'POSITIVE'`, `'NEGATIVE'`], default `'ANY'`

    axis1_region
    :   Action execution region for the second input axis

        - `ANY`
          Any – Use any axis region for operator execution.
        - `POSITIVE`
          Positive – Use positive axis region only for operator execution.
        - `NEGATIVE`
          Negative – Use negative axis region only for operator execution.

        Type:
        :   enum in [`'ANY'`, `'POSITIVE'`, `'NEGATIVE'`], default `'ANY'`

    component_paths
    :   OpenXR component paths

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

    name
    :   Name of the action map binding

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

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

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

    profile
    :   OpenXR interaction profile path

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

    threshold
    :   Input threshold for button/axis actions

        Type:
        :   float in [0, 1], default 0.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 Outputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   Mesh component of the input geometry.

Curve
:   Curve component of the input geometry.

Point Cloud
:   Point cloud component of the input geometry.

Volume
:   Volume component of the input geometry.

Instances
:   Instances component of the input geometry. Even if the instances contain geometry data with
    one of the other types, all instances will be added to this output.
    A [Realize Instances Node](../../instances/realize_instances.html) can be added to move the data from
    geometry instances to their corresponding outputs.