PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use TextureNodeHueSaturation(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeHueSaturation(TextureNode)

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Limitations and how is it used in Blender Python scripting?

assistant: # Limitations

EEVEE’s goal is to be an interactive render engine. Some features may not be there yet or
may be impossible to implement into EEVEE’s architecture without compromising performance.

Here is a rather exhaustive list of all the limitations you can expect while working with EEVEE.
user: Give a detailed overview of Animating Stabilization Parameters: syntax, arguments, return values, common patterns.

assistant: Animating some parameters over duration of the shot is often necessary, at least to get the final touch,
including control of the scale factor to hide the dancing black borders.
Unfortunately there is a **known limitation** in the current version:
it is not possible to open the generic animation editors (Graph editor and Dope Sheet)
for animation data beyond the 3D scene. So, while it *is possible* to set keyframes *right within the UI controls*
of the stabilizer (either through pressing the `I` key or with the help of the context menu),
it is not possible to manipulate the resulting curves graphically.
The only way to readjust or remove a misguided keyframe is to locate
the timeline to the very frame and then use the context menu of the animated UI control.
(Hint: the color of the UI control changes when you have located at precisely the frame number of the keyframe.)
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`MetaBall.elements`](bpy.types.MetaBall.html#bpy.types.MetaBall.elements "bpy.types.MetaBall.elements") - [`MetaBallElements.active`](bpy.types.MetaBallElements.html#bpy.types.MetaBallElements.active "bpy.types.MetaBallElements.active") | - [`MetaBallElements.new`](bpy.types.MetaBallElements.html#bpy.types.MetaBallElements.new "bpy.types.MetaBallElements.new") - [`MetaBallElements.remove`](bpy.types.MetaBallElements.html#bpy.types.MetaBallElements.remove "bpy.types.MetaBallElements.remove") |
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Volume Displace modifier.

Texture
:   The texture that is evaluated at every voxel to determine how far and in what direction to displace.

Strength
:   Controls how far voxels are displaced.

Sample Radius
:   Smaller values result in better performance, but might cut off the volume outside.

Mid Level
:   This should be modified if the texture offsets the entire volume in one direction and you want to center it again.
    For performance reasons, the displaced volume should stay close to its original position.
user: Explain Tool Settings in complete detail according to the official Blender documentation.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the line.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

[image reference removed]

The Bone Constraints Properties in Pose Mode,
with an Inverse Kinematics constraint added to the active bone.

As bones behave like objects in *Pose Mode*, they can also be constrained.
This is why the *Constraints* tab is shown in both *Object Mode* and *Edit Mode*.
This panel contains the constraints *of the active bone*
(its name is displayed at the top of the panel, in the *To Bone:…* static text field).

Constraining bones can be used to control their degree of freedom
in their pose transformations, using e.g. the *Limit* constraints.
You can also use constraints to make a bone track another object/bone
(inside the same object, or in another armature), etc.
And the [inverse kinematics feature](inverse_kinematics/introduction.xhtml#bone-constraints-inverse-kinematics)
is also mainly available through the *IK Solver* constraint, which is specific to bones.

For example, a human elbow cannot rotate backward (unless the character has broken their arm),
nor to the sides, and its forward and roll rotations are limited in a given range.
(E.g. depending on the rest position of your elbow, it may be from (0 to 160) or from (-45 to 135).)

So you should apply a *Limit Rotation* constraint to the forearm bone
(as the elbow movement is the result of rotating the forearm bone around its root).

Using bones in constraints, either as owners or as targets, is discussed in detail
in the [constraints pages](../../../constraints/index.xhtml).
user: Give a detailed overview of Vertices: syntax, arguments, return values, common patterns.

assistant: # Vertices

*Instance Vertices* allows you to replicate child objects
at the location of every vertex of the parent object.

Align to Vertex Normal
:   Rotates all instanced objects according to the corresponding vertex normals of the parent mesh.

    To change the axis of direction of the instanced objects,
    select the child object and change the [Tracking Axis](../relations.html#bpy-types-object-track-axis).

There are actually two approaches to modeling using instanced vertices.
They can be used as an arranging tool,
allowing you to model geometrical arrangements of objects (e.g. the columns of a Greek temple,
the trees in a garden, the desks in a classroom).
The object can be of any object type which Blender supports.
The second approach is to use them to model an object starting from a single part of it
(e.g. the spikes in a club, the thorns of a sea-urchin, the tiles in a wall, the petals in a flower).
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Output
:   Outputs the value from the input corresponding to the selected menu item, unchanged.

For each menu entry, an additional Boolean output is created.
The output corresponding to the selected item is *true*, and all others are *false*.
These Boolean outputs can be used to trigger different node branches, control visibility,
or drive conditional operations elsewhere in the node tree.
user: Provide the full official documentation entry for Mouse Clicks, preserving all code examples.

assistant: If at least one bone is selected, `Ctrl`-`RMB`-clicking adds a new bone.

About the new bone’s tip:

After you `Ctrl`-`RMB`-clicked it becomes the active element in the armature,
it appears to be right where you clicked, but (as in mesh editing)
it will be on the plane parallel to the view and passing through the 3D cursor.

The position of the root and the parenting of the new bone depends on the active element:

[[image reference removed]](../../../../_images/animation_armatures_bones_editing_extrude_mouse-clicks-1.png)

`Ctrl`-clicking when the active element is a bone.

If the active element is a *bone*:

- The new bone’s root is placed on the active bone’s tip.
- The new bone is parented and connected to the active bone
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a tip.](#fig-rig-bone-active-tip)).

[[image reference removed]](../../../../_images/animation_armatures_bones_editing_extrude_mouse-clicks-2.png)

`Ctrl`-clicking when the active element is a tip.

If the active element is a *tip*:

- The new bone’s root is placed on the active tip.
- The new bone is parented and connected to the bone owning the active tip
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a tip.](#fig-rig-bone-active-tip)).

[[image reference removed]](../../../../_images/animation_armatures_bones_editing_extrude_mouse-clicks-3.png)

`Ctrl`-clicking when the active element is a disconnected root.

If the active element is a *disconnected root*:

- The new bone’s root is placed on the active root.
- The new bone is **not** parented to the bone owning the active root
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a disconnected root.](#fig-rig-bone-disconnected-tip)).

And hence the new bone will **not** be connected to any bone.

[[image reference removed]](../../../../_images/animation_armatures_bones_editing_extrude_mouse-clicks-4.png)

`Ctrl`-clicking when the active element is a connected root.

If the active element is a *connected root*:

- The new bone’s root is placed on the active root.
- The new bone **is** parented and connected to the parent of the bone owning the active root
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a connected root.](#fig-rig-bone-connected-root)).

This should be obvious because if the active element is a connected root
then the active element will be also the tip of the parent bone,
so it is the same as the second case.

As the tip of the new bone becomes the active element,
you can repeat these `Ctrl`-`RMB` clicks several times,
to consecutively add several bones to the end of the same chain.
user: Show practical ways to work with Unsharp Mask Node in a Blender add-on or script – include code.

assistant: # Unsharp Mask Node

[image reference removed]

The *Unsharp Mask* node enhances the apparent sharpness of an image by increasing edge contrast.
Despite its name, it does not blur the image; instead, it sharpens details by subtracting a
blurred (unsharp) version of the image from the original and emphasizing the resulting edges.

This technique is commonly used in photography, printing, and digital compositing
to improve clarity and definition.
user: Show practical ways to work with Space in a Blender add-on or script – include code.

assistant: The *Target Space* is the reference frame for retrieving the location coordinates,
rotation angles, and scale factors of the *Target*. The *Owner Space* is the
reference frame for applying those numbers to the object or bone that owns the constraint.

[image reference removed]

Using *World Space* for both *Target* and *Owner* places the constrained object
at the same location as the target regardless of their parents.

### Space Types

World Space
:   Use the transformation relative to the world axes.

Custom Space
:   Use the transformation relative to an arbitrary object or bone.

Pose Space Bones Only
:   Use the transformation relative to the armature object.

Local Space
:   For an object, use the transformation relative to its parent.

    For a bone, use the transformation relative to its rest state, after that rest state was
    transformed by the bone’s ancestors. (If the bone has no other constraints, this is its
    transformation as shown in the [Properties Editor](../../../editors/properties_editor.xhtml) while in Pose Mode.)

Local with Parent Bones Only
:   Use the transformation relative to the bone’s rest state. Unlike *Local Space*, this includes
    the rotation and location difference caused by rotating any ancestor bone.

Local Space (Owner Orientation) Bone Targets Only
:   This space is intended to be used with the *Owner* set to *Local Space*. It retrieves the *Local Space*
    of the Target bone, adjusted to work with the rest orientation of the Owner bone. The result is that,
    if the parent bones of both the Target and the Owner are in their rest pose, the Owner will
    undergo the same transformation as the Target *in armature space*. The following image
    demonstrates this:

    [image reference removed]

    - The left hand armature contains the Target bone which we rotate manually.
    - The middle armature has a constraint that copies the *Local Space* rotation of the Target bone.
      If the Target bone is rotated around its Y axis, this Owner bone rotates by the same amount around
      *its own* Y axis.
    - The right hand armature has a constraint that copies the *Local Space (Owner Orientation)* rotation
      of the Target bone. If the Target bone is rotated around its Y axis, the Owner bone rotates around
      *that same* axis in armature space. Initially this is the same as using *Pose Space* or even
      *World Space*, but if the parent bones are rotated as well, the result will be different.
user: Provide the full official documentation entry for Selecting Bones, preserving all code examples.

assistant: # Selecting Bones

You can select and edit bones of armatures in *Edit Mode* and in *Pose Mode*.
Here, we will see how to select bones in *Edit Mode*.
Selecting bones in *Pose Mode* is similar to selecting in *Edit Mode*
with a few specific differences that will be detailed in
the [posing part](../posing/selecting.xhtml).

Similar to [vertex/edge selection](../../../modeling/meshes/selecting/introduction.xhtml) in meshes,
there are two ways to select whole bones in *Edit Mode*:

1. Directly, by selecting the bone’s body.
2. Selecting both of its joints (root and tip).

This is an important point to understand,
because selecting bones’ joints only might lead to non-obvious behavior,
with respect to which bone you actually select.

Note that unlike the mesh display type, the armature display type has no effect on selection behavior.
In other words, you can select a bone’s joint or body the same way regardless of
the bone visualization chosen.
user: Provide the full official documentation entry for Your First Armature, preserving all code examples.

assistant: In order to see what we are talking about, let us try to add the default armature in Blender.

(Note that armature editing details are explained in
the [armatures editing section](bones/editing/index.html).)

Open a default scene, then:

1. Delete all objects in the scene.
2. Make sure the cursor is in the world origin with `Shift`-`C`.
3. Press `Numpad1` to see the world in Front view.
4. Add a *Single Bone* (Add ‣ Armature).
5. Press `NumpadPeriod` to see the armature at maximum zoom.

[image reference removed]

The default armature.
user: Show practical ways to work with FunctionNodeSeparateMatrix(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeSeparateMatrix(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.FunctionNodeSeparateMatrix(*FunctionNode*)
:   Split a 4x4 matrix into its individual values

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

assistant: # Collisions

In most cases, a piece of cloth does not just hang there in 3D space,
it collides with other objects in the environment. To ensure proper simulation,
there are several items that have to be set up and working together:

- The *Cloth* object must be told to participate in collisions.
- Optionally (but recommended) tell the cloth to collide with itself.
- Other objects must be visible to the *Cloth* object *via* shared layers.
- The other objects must be mesh objects.
- The other objects may move or be themselves deformed by other objects (like an armature or shape key).
- The other mesh objects must be told to deflect the cloth object.
- The blend-file must be saved in a directory so that simulation results can be saved.
- You then *Bake* the simulation. The simulator computes the shape of the cloth for a frame range.
- You can then edit the simulation results, or make adjustments to the cloth mesh, at specific frames.
- You can make adjustments to the environment or deforming objects,
  and then re-run the cloth simulation from the current frame forward.

[image reference removed]

Cloth Collisions panel.

Quality
:   A general setting for how fine and good a simulation you wish.
    Higher numbers take more time but ensure less tears and penetrations through the cloth.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The first step in the rendering process is to determine and set the output settings.
This includes render size, frame rate, pixel aspect ratio, output location, and file type.

When rendering a single frame, the output should be a single image format and not a video.
Several [image formats](../../files/media/image_formats.xhtml) are available.

Images can also be used for rendering animations which has a couple advantages.
For example, when rendering animations to image file formats the render job can be canceled
and resumed at the last rendered frame by changing the frame range.
This is useful if the animation takes a long time to render
and the computers resources are needed for something else.

Images can then be encoded to a video by adding the rendered image sequence into
the [Video Sequencer](../../editors/video_sequencer/sequencer/index.xhtml) and choosing an appropriate
[Video Output](../../files/media/video_formats.xhtml).
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: ### Baking

Baking converts high-resolution geometry details, such as sculpted displacement or surface normals,
into 2D texture maps. These maps can then be applied to a lower-resolution mesh to reproduce
the appearance of fine surface detail without the performance cost of dense geometry.

This process is essential for workflows where high-resolution sculpting data is transferred to
low-resolution meshes for rendering or game engines.

To generate a normal or displacement map, use the
[Bake from Multires](../../../render/cycles/baking.xhtml#bpy-types-rendersettings-use-bake-multires) option in the Render panel.
This feature compares two resolution levels of the Multiresolution modifier:

- **Viewport Levels:** Used as the *low-resolution* base mesh.
- **Render Levels:** Used as the *high-resolution* detail mesh.

The difference between these two levels is baked into a texture map.

#### Bake Types

The *Bake Type* determines what kind of surface information is extracted from the Multiresolution modifier.

- **Normals:**
  Bakes surface normal direction differences between the base and detailed levels.
  The resulting normal map encodes lighting information that reproduces fine sculpted detail
  in shading without modifying the actual geometry.
  Ideal for use with normal-mapped materials in Cycles, Eevee, and real-time engines.
- **Displacement:**
  Bakes height differences between the base and high-resolution mesh as a grayscale image.
  Lighter areas represent raised regions and darker areas represent recessed areas.
  This map can be used for *true* displacement in render engines or for parallax/height-based shading.
- **Vector Displacement:**
  Bakes 3D displacement vectors representing the full spatial offset from the base to the detailed surface.
  Unlike regular displacement, this method can capture overhangs and non-vertical displacements,
  providing a more accurate representation of complex sculpted details.

  The resulting texture encodes XYZ displacement in the RGB color channels.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Vertex Index
:   The index of the vertex for which to find the edges.

Weights
:   The weights of the edges in the geometry. Unlike the other inputs which follow
    the context domain, this one is always evaluated in the Edge domain.

    The edges are sorted by their associated weight in ascending order.
    Edges with the same weight are sorted by their index.

Sort Index
:   The 0-based index of the edge to select from the vertex’s sorted edges.
    If this value is outside the range of valid indices, it wraps around.
user: What is Quaternion to Rotation Node and how is it used in Blender Python scripting?

assistant: # Quaternion to Rotation Node

[image reference removed]

The *Quaternion to Rotation* node converts a [quaternion rotation](../../../../advanced/appendices/rotations.html#quaternion-mode) to a standard rotation.
user: Provide the full official documentation entry for Creating a Force Field, preserving all code examples.

assistant: To create a single force field,
you can select Add ‣ Force Field and select the desired force field.
This method creates an empty with the force field attached.

Examples of an empty with the force field attached.

|  |  |  |
| --- | --- | --- |
| ../../../_images/physics_forces_force-fields_types_vortex_visualzation.png   Vortex: force field. | ../../../_images/physics_forces_force-fields_types_wind_visualzation.png   Wind: force field. | ../../../_images/physics_forces_force-fields_types_force_visualzation.png   Force: force field. |

To create a field from an existing object you have to select the object and
change to the *Physics* tab. Select the field type in the *Fields* menu.
user: Explain Linestyle Thickness Modifier Type Items in complete detail according to the official Blender documentation.

assistant: # Linestyle Thickness Modifier Type Items

ALONG_STROKE:
:   Along Stroke.

CALLIGRAPHY:
:   Calligraphy.

CREASE_ANGLE:
:   Crease Angle.

CURVATURE_3D:
:   Curvature 3D.

DISTANCE_FROM_CAMERA:
:   Distance from Camera.

DISTANCE_FROM_OBJECT:
:   Distance from Object.

MATERIAL:
:   Material.

NOISE:
:   Noise.

TANGENT:
:   Tangent.
user: Describe CompositorNodeFilter(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeFilter(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.CompositorNodeFilter(*CompositorNode*)
:   Apply common image enhancement filters

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

assistant: These tools will recalculate the normals of selected faces so that they point outside
(respectively inside) the volume that the face belongs to.
The volume does not need to be closed; inside and outside are determined by the angles with adjacent faces.
This means that the face of interest must be adjacent to at least one non-coplanar other face.
For example, with a *Grid* primitive, recalculating normals does not have a meaningful result.
user: Explain Direction of Time in complete detail according to the official Blender documentation.

assistant: F-Curves are similar to [Curve objects](../../../modeling/curves/introduction.html) in that they interpolate
between a set of user-defined control points. However, because their purpose is to define a *single*
value on every frame, there’s an important difference: F-curves can’t be closed or otherwise made to
turn back on themselves. They always continue going further to the right.

If you try to make a curve go left by dragging one control point past another,
it switches the order of the points to prevent this.

Two control points switching: the curve cannot go back in time!

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_introduction_moving1.png   Before moving the second keyframe. | ../../../_images/editors_graph-editor_fcurves_introduction_moving2.png   After moving the second keyframe. |
user: Describe Shading Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Shading Type Items

WIREFRAME:
:   Wireframe.

    Display only edges of geometry without surface shading.

SOLID:
:   Solid.

    Display objects with flat lighting and basic surface shading.

MATERIAL:
:   Material Preview.

    Preview materials using predefined environment lights.

RENDERED:
:   Rendered.

    Preview the final scene using the active render engine.
user: Provide the full official documentation entry for Edge Length Node, preserving all code examples.

assistant: # Edge Length Node

[image reference removed]

The *Edge Length* node outputs the length of each edge in a mesh.
It calculates the distance between the two vertices that define each edge.

This node can be used for geometric analysis, mesh-based effects, or procedural operations
that depend on edge length (such as adaptive subdivision, weight mapping, or trimming).
user: Provide the full official documentation entry for Mist Pass, preserving all code examples.

assistant: Mist can greatly enhance the illusion of depth in your rendering. To create mist,
Blender generates a render layer with a depth map ranging between 0.0 and 1.0
that can be used in the Compositor to generate a mist effect.

Start
:   The distance from the camera at which the mist starts to fade in.

Depth
:   The distance from *Start* of the mist, that it fades in over.
    Objects further from the camera than *Start + Depth* are completely hidden by the mist.

Falloff
:   The curve function that controls the rate of change of the mist’s strength further and further into the distance.

    Quadratic:
    :   Uses the same calculation as light falloff (\(1\over{x^2}\)) and provides the smoothest
        transition from transparent (0.0) to opaque (1.0).

    Linear:
    :   Has a steeper start than quadratic (\(1\over{x}\)).

    Inverse Quadratic:
    :   Has the steepest start (\(1\over{\sqrt{x}}\)) and approaches 1.0 faster than the other two functions.

[image reference removed]

Mist example
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:25-Manual-World-Mist-Example1.blend)).
user: Show practical ways to work with Using Texture Nodes in a Blender add-on or script – include code.

assistant: The default Blender layout has no workspace containing the Texture Node Editor.
You need to manually open it in an [area](../../interface/window_system/areas.xhtml) of choice.

Once the editor is open, you first need to set the empty *Texture Type* selector to *Brush*,
after which you can use the [Data-Block Menu](../../interface/controls/templates/data_block.xhtml)
to start creating textures. Note that you need to enable *Use Nodes* in the header
before you can add nodes.
user: How do I use NodeGroup(NodeInternal) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeGroup(NodeInternal)

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

*class* bpy.types.NodeGroup(*NodeInternal*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: This navigation method behaves like a typical first person game.
It works with a combination of keyboard keys and mouse movement.

### Usage

Move the mouse in the direction you want to look and use the keys
listed below to walk around the scene.

When you are happy with the new view, press `LMB` to confirm.
In case you want to go back to where you started, press `Esc` or `RMB`.

All these keys are also listed in the Status Bar while navigating.
Settings like mouse sensitivity and default speed can be adjusted in the
[Preferences](../../preferences/navigation.xhtml).

|  |  |
| --- | --- |
| `W`/`Up` | Move forward. |
| `S`/`Down` | Move backward. |
| `A`/`Left` | Strafe left. |
| `D`/`Right` | Strafe right. |
| `E` | Move up (global) – only available if *Gravity* is off. |
| `Q` | Move down (global) – only available if *Gravity* is off. |
| `R` | Move up (local) – only available if *Gravity* is off. |
| `F` | Move down (local) – only available if *Gravity* is off. |
| `Spacebar` | Teleport to the location at the crosshair (offset by the *Camera Height* value set in the Preferences). |
| `WheelUp`/`NumpadPlus` | Increase the movement speed. |
| `WheelDown`/`NumpadMinus` | Decrease the movement speed. |
| `Shift` | Speed up the movement temporarily. |
| `Alt` | Slow down the movement temporarily. |
| `V` | Jump – only available if *Gravity* is on. |
| `Tab` | Toggle *Gravity*. |
| `Z` | Correct the Z axis of the view (smoothly roll it to ensure it’s upright, not tilted to a side). |
| `Period` | Increases the jump height. |
| `Comma` | Decreases the jump height. |
user: Describe Collisions from the Blender manual or Python API, including usage steps and snippets.

assistant: Quality
:   A general setting for how fine and good a simulation you wish.
    Higher numbers take more time but ensure less tears and penetrations through the hair.

Distance
:   The distance another object must get to the hair for
    the simulation to repel the hair out of the way.
    Smaller values might cause errors but provide some speed-up while
    larger will give unrealistic results if too large and can be slow.
    It is best to find a good in between value.

Impulse Clamping
:   Prevents explosions in tight and complicated collision situations
    by restricting the amount of movement after a collision.

Collision Collection
:   Only objects that are a part of this [Collection](../../../scene_layout/collections/index.html)
    can collide with the hair. Note that these objects must also have Collision physics enabled.
user: Show practical ways to work with Categories in a Blender add-on or script – include code.

assistant: There are four categories of built-in modifiers:

Edit
:   Similar to the *Deform* modifiers (see below),
    however, they usually do not directly affect the geometry of the object,
    but some other data, such as vertex groups.

Generate
:   Constructive/destructive modifiers that will affect the whole [Topology](../../glossary/index.html#term-Topology) of the mesh.
    They can change the general appearance of the object, or add new geometry to it…

Deform
:   Unlike *Generate* ones above, these modifiers only change the shape of an object, without altering its topology.

Simulate
:   Represent [physics simulations](../../physics/index.html). In most cases, they are automatically added to
    the modifiers stack whenever a *Particle System* or *Physics* simulation is enabled. Their only role is to define
    the position in the modifier stack from which is taken the base data for the simulation they represent.
    As such, they typically have no properties, and are controlled by settings exposed in
    separate sections of the [Properties Editor](../../editors/properties_editor.html).

You will also notice a category called “Hair”,
this category comes from a bundled [Asset Library](../../glossary/index.html#term-Asset-Library) that is distributed with Blender.
See [Hair Nodes](../geometry_nodes/hair/index.html) for more information.

Users can make their own categories by making geometry node groups [assets](../../glossary/index.html#term-Asset)
and assigning them to a [Asset Catalog](../../glossary/index.html#term-Asset-Catalog). This catalog name will be the category name.
If a user creates a catalog with the same name as one of the built-in categories
the node group will be added to the bottom of the corresponding menu.

Node Groups that are non-assets or that do not belong to a category will be available in the “Unassigned” sub-menu.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: Start by loading a video file into the [Movie Clip Editor](../../../editors/clip/introduction.xhtml)
and using [motion tracking](../../../movie_clip/tracking/introduction.xhtml) to track at least
eight [markers](../../../movie_clip/tracking/clip/marker.xhtml) in the real-world scene.
Then use [Solve Camera/Object Motion](../../../movie_clip/tracking/clip/editing/track.xhtml#bpy-ops-clip-solve-camera) to reconstruct the motion of the physical camera,
and finally add this constraint to a Blender camera.
user: What is Motor Constraint and how is it used in Blender Python scripting?

assistant: # Motor Constraint

The motor constraint causes translation and/or rotation between two entities.
It can drive two objects apart or together.
It can drive simple rotation, or rotation and translation
(although it will not be constrained like a screw since the translation
can be blocked by other physics without preventing rotation).

The rotation axis is the X axis of the object hosting the constraint.
This is in contrast with the Hinge which uses the Z axis.
Since the Motor is vulnerable to confusing perturbations without a matching Hinge constraint,
special care must be taken to align the axes.
Without proper alignment, the motor will appear to have no effect
(because the hinge is preventing the motion of the motor).

[image reference removed]

*Motor* constraint options.
user: How do I use CompositorNodeFlip(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeFlip(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.CompositorNodeFlip(*CompositorNode*)
:   Flip an image along a defined axis

    *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: Describe Interior Faces from the Blender manual or Python API, including usage steps and snippets.

assistant: Selects faces that may have been accidentally created inside the mesh instead of
on the mesh’s surface. Specifically, it selects faces with “abnormal” neighbors
(multiple neighbors connected to the same edge), as well as any “normal” neighbors
of those faces.
user: Explain Modifying a Pose Asset in complete detail according to the official Blender documentation.

assistant: A pose asset can be modified after it has been created.
This is only possible for pose assets in the current file or that have been exported into
an .asset.blend file.
For that, an operator has been created which can be accessed by right clicking a pose asset.
That operator works on the active object, so updating the asset from selected bones
of multiple armatures won’t work. It will find the best matching slot, falling back to
the first one.
There are 4 modes.

Adjust Pose
:   Update existing channels in the pose asset from the selected bones,
    but don’t remove or add any channels.

Replace
:   Completely replace all channels in the pose asset with the channels of the selected bones.

Add
:   Add channels of the selected bones to the pose asset. Existing channels will be updated.

Remove
:   Remove channels of the selected bones from the pose asset.
user: Give a detailed overview of Brush Types: syntax, arguments, return values, common patterns.

assistant: See [Brush Type](../brush/brush_settings.xhtml#sculpt-tool-settings-brush-type).

Available brush types are listed here, together with brushes from the
*Essentials* asset library using them.

Paint Vertex
:   Brushes: Paint Hard, Paint Soft, Paint Hard Pressure, Paint Soft Pressure, Airbrush

    Paints a specified color over the object.

Blur
:   Brushes: Blur

    Smooths out the colors of adjacent vertices. In this mode the Color
    Value is ignored. The strength defines how much the colors are blurred.

Average
:   Brushes: Average

    Smooths color by painting the average resulting color from all colors under the brush.

Smear
:   Brushes: Smear

    Smudges colors by grabbing the colors under the brush and “dragging” them.
    This can be imagined as a finger painting tool.
user: How do I use Curvature 3D in Blender? Include parameters, examples, warnings and best practices.

assistant: # Curvature 3D

A modifier based on radial curvatures of the underlying 3D surface.
The [curvature](https://en.wikipedia.org/wiki/Curvature) of a 2D curve
at a point is a measure of how quickly the curve turns at the point.
The quicker the turn is, the larger the curvature is at the point.
The curvature is zero if the curve is a straight line.
Radial curvatures are those computed for a 2D curve that appears at the cross section
between the 3D surface and a plane defined by the view point (camera location)
and the normal direction of the surface at the point.

For radial curvatures to be calculated (and therefore for this modifier to have any effect),
the *Face Smoothness* option has to be turned on and the object needs to have *Smooth Shading*.

Curvature Min, Max
:   The limits of the mapping.
    If the current point of the stroke is at *Min Curvature* or less from the target,
    it will take the start point of the mapping. And conversely,
    if it is at *Max Curvature* or more from the target, it will take the end-point value of the mapping.

[image reference removed]

Curvature 3D modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_curvature_3d.blend)).
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`GreasePencilTreeNode.name`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.name "bpy.types.GreasePencilTreeNode.name") - [`GreasePencilTreeNode.hide`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.hide "bpy.types.GreasePencilTreeNode.hide") - [`GreasePencilTreeNode.lock`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.lock "bpy.types.GreasePencilTreeNode.lock") - [`GreasePencilTreeNode.select`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.select "bpy.types.GreasePencilTreeNode.select") - [`GreasePencilTreeNode.use_onion_skinning`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.use_onion_skinning "bpy.types.GreasePencilTreeNode.use_onion_skinning") | - [`GreasePencilTreeNode.use_masks`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.use_masks "bpy.types.GreasePencilTreeNode.use_masks") - [`GreasePencilTreeNode.channel_color`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.channel_color "bpy.types.GreasePencilTreeNode.channel_color") - [`GreasePencilTreeNode.next_node`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.next_node "bpy.types.GreasePencilTreeNode.next_node") - [`GreasePencilTreeNode.prev_node`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.prev_node "bpy.types.GreasePencilTreeNode.prev_node") - [`GreasePencilTreeNode.parent_group`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.parent_group "bpy.types.GreasePencilTreeNode.parent_group") |
user: Give a detailed overview of SpaceImageOverlay(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # SpaceImageOverlay(bpy_struct)

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

*class* bpy.types.SpaceImageOverlay(*bpy_struct*)
:   Settings for display of overlays in the UV/Image editor

    passepartout_alpha
    :   Opacity of the darkened overlay outside the render region

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

    show_grid_background
    :   Show the grid background and borders

        Type:
        :   boolean, default False

    show_overlays
    :   Display overlays like UV Maps and Metadata

        Type:
        :   boolean, default False

    show_render_size
    :   Display the region of the final render

        Type:
        :   boolean, default False

    show_text_info
    :   Display overlay text

        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