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

assistant: # XrUserPaths(bpy_struct)

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

*class* bpy.types.XrUserPaths(*bpy_struct*)
:   Collection of OpenXR user paths

    new(*path*)
    :   new

        Parameters:
        :   **path** (*string**,* *(**never None**)*) – Path, OpenXR user path

        Returns:
        :   User Path, Added user path

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

    remove(*user_path*)
    :   remove

        Parameters:
        :   **user_path** ([`XrUserPath`](bpy.types.XrUserPath.html#bpy.types.XrUserPath "bpy.types.XrUserPath"), (never None)) – User Path

    find(*path*)
    :   find

        Parameters:
        :   **path** (*string**,* *(**never None**)*) – Path, OpenXR user path

        Returns:
        :   User Path, The user path with the given path

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

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

assistant: Will create a palm system based on the distance between palm bones.

Requirement: At least two bones child of the same parent.
The property has to be set on the inner palm bones (think it as index’s metacarpus),
the rig control will appear on the last palm bone (think it as pinky’s metacarpus).

Both Sides
:   Generates controls on both sides of the palm, with influence on inner bones blended between them.

Primary Rotation Axis (X, Z)
:   Defines the automatic rotation axis to be used on the palm bones.
user: Provide the full official documentation entry for Enabling Add-on, preserving all code examples.

assistant: This add-on is enabled by default. In case it is not:

1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “UV Layout” and check the *Enable Add-on* checkbox.
user: What is CompositorNodeSceneTime(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeSceneTime(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.CompositorNodeSceneTime(*CompositorNode*)
:   Input the current scene time in seconds or frames

    *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 Properties in a Blender add-on or script – include code.

assistant: Fill Type
:   How the circles at the top and bottom are filled with faces when their radius is larger than zero.

    None:
    :   Do not fill the circles.

    N-Gon:
    :   Fill the innermost circles with a single face.

    Triangles:
    :   Fill the innermost circles with triangles connected to a vertex in the center.
user: What is Annotations and how is it used in Blender Python scripting?

assistant: Annotation tool strokes can be enabled/disabled with the checkbox in the panel header.
It is a standard annotations panel where annotation layers and frames can be controlled.
There is one difference in the behavior of the annotation tools from other areas –
when a new layer is created “on-demand” (when making a stroke without adding a layer before this)
the default color for the layer is set to pink. This heightens the color contrast to make
the stroke more noticeable on all kinds of movies.

Data Source
:   Determines the data-block type the current annotation layer is stored.

    Clip:
    :   Store the current annotation layer with the active *Movie Clip* data-block.

    Track:
    :   Store the current annotation layer with the active *Track* data-block.
user: Describe Quick Start from the Blender manual or Python API, including usage steps and snippets.

assistant: Open the Command Prompt, go to the directory where Blender is installed,
and then run Blender:

```
cd c:\<blender installation directory>
blender
```

You can also add the Blender folder to your system `PATH` so that you do not have to `cd` to it each time.
user: Show practical ways to work with Angular Velocity in a Blender add-on or script – include code.

assistant: Lets you configure if and how particles should spin over time.
*Dynamic* needs to be enabled for this to work.

Axis
:   The axis to spin around. If this is set to *Velocity*, *Horizontal*, or *Vertical*,
    particles will additionally spin to keep the same orientation relative to their
    direction of movement, even if *Amount* is zero.

    None
    :   Spinning is disabled.

    Velocity
    :   Spin around the particle’s velocity vector.

    Horizontal
    :   Spin around the axis that’s horizontal (lying in the global XY plane)
        and perpendicular to the particle’s velocity. Particles moving along the
        global Z axis won’t spin because no unique rotation axis exists in this case.

    Vertical
    :   Spin around the axis that’s perpendicular to both the particle’s velocity
        and the above *Horizontal* axis. Particles moving along the global Z axis
        won’t spin.

    Global X, Y, Z
    :   Spin around the chosen global axis.

    Random
    :   Spin around a random axis.

Amount
:   How fast to spin around the *Axis*.
user: Describe Workflow from the Blender manual or Python API, including usage steps and snippets.

assistant: This node is often used for additional control in color grading, replacing the
display and view transform in the color management settings.

To avoid doubling up transforms, it is recommended to:

- Add a second Convert to Display node with the Standard view transform and
  Inverse enabled, as the last node in the compositing node graph.
- Set the view transform to Standard in the scene color management settings.

The compositor will then output colors in the
[working space](../../../render/color_management/color_spaces.xhtml#bpy-types-blendfilecolorspace-working-space) as usual,
but with color grading baked in. Unlike workflows using the Raw view
transform, this works correctly with the video sequencer and OpenEXR output.
user: Give a detailed overview of Troubleshooting Windows – NVIDIA: syntax, arguments, return values, common patterns.

assistant: # Troubleshooting Windows – NVIDIA

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`FreestyleLineStyle.thickness_modifiers`](bpy.types.FreestyleLineStyle.html#bpy.types.FreestyleLineStyle.thickness_modifiers "bpy.types.FreestyleLineStyle.thickness_modifiers") |  |
user: Show practical ways to work with Color Mix Strip in a Blender add-on or script – include code.

assistant: # Color Mix Strip

The *Color Mix* effect strip mixes two strips by working on
the individual and corresponding pixels of the two input strips.

This effect can do the exact same operation as the Add, Subtract,
or Multiply effect strips but also other color blending modes.
user: Provide the full official documentation entry for Exporting, preserving all code examples.

assistant: ### General

Format: ASCII
:   Exports the stl-file in ASCII format rather than as a binary format

Batch
:   Export each object as a separate STL file.

Include: Selection Only
:   When checked, only selected objects are exported.
    Instanced objects, for example collections that are instanced in the scene,
    are considered ‘selected’ when their instancer is selected.

Scale
:   Value by which to scale the exported objects in relation to the world’s origin.

Scene Unit
:   Apply current scene’s unit (as defined by unit scale) to exported data.

Forward, Up
:   Since many applications use a different axis for ‘Up’, these are axis conversion for these settings,
    Forward and Up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y Forward, Z Up (since the front view looks along the +Y direction).
    For example, it’s common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed.

### Geometry

Apply Modifiers
:   Export objects using the evaluated mesh, meaning the resulting mesh after all
    [Modifiers](../../modeling/modifiers/index.xhtml) have been calculated.
user: How do I use PreferencesKeymap(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # PreferencesKeymap(bpy_struct)

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

*class* bpy.types.PreferencesKeymap(*bpy_struct*)
:   Shortcut setup for keyboards and other input devices

    active_keyconfig
    :   The name of the active key configuration

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

    show_ui_keyconfig
    :   Type:
        :   boolean, default True

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Combine Cylindrical Node in complete detail according to the official Blender documentation.

assistant: # Combine Cylindrical Node

[image reference removed]

The *Combine Cylindrical* node converts cylindrical coordinates (R, Φ, Z)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Cylindrical](separate_cylindrical.xhtml) node.

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: What is GpVertexPaint(Paint) and how is it used in Blender Python scripting?

assistant: # GpVertexPaint(Paint)

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

*class* bpy.types.GpVertexPaint(*Paint*)
:   *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 Using Texture Nodes in complete detail according to the official Blender documentation.

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: Explain Geometry Attribute Constraint in complete detail according to the official Blender documentation.

assistant: # Geometry Attribute Constraint

The *Geometry Attribute* constraint transforms an object or bone according to a target object’s
sampled geometry attribute data. This allows motion and deformation to be driven directly by
procedural geometry outputs, such as positions or orientations from Geometry Nodes.
user: What is SurfaceCurve(Curve) and how is it used in Blender Python scripting?

assistant: # SurfaceCurve(Curve)

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

*class* bpy.types.SurfaceCurve(*Curve*)
:   Curve data-block used for storing surfaces

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

assistant: [image reference removed]

Curve Stroke panel.

Type
:   Type of curve to use for drawing.

    Poly:
    :   Bézier Curve with straight line segments (auto handles).

    Bézier:
    :   Tolerance
        :   Lower values give a result that is closer to the drawing stroke,
            while higher values give more smoothed results.

        Method
        :   Refit:
            :   Incrementally refits the curve (gives best results).

            Split:
            :   Splits the curve until the tolerance is met (gives a better drawing performance).

        Detect Corners
        :   Detects corners while drawing based on a specified angle;
            Any angles above the specified value are considered corners.
            If a corner is detected, the curve uses non-aligned handles
            for the corner resulting in a more crisp corner.

Taper Start, End
:   Taper factor for the radius of the start and end points along the curve.

Radius Min
:   Minimum radius when the minimum pressure is applied (also the minimum when tapering).

Max
:   Radius to use when the maximum pressure is applied (or when a tablet is not used).

Use Pressure
:   Uses stylus pressure to control the radius of the curve.

Depth
:   Controls where and how the curves are drawn.

    Cursor:
    :   Uses the depth under the cursor to draw curves.

    Surface:
    :   Used to draw on top of other objects.

        Project Onto Selected
        :   Only project the strokes onto selected objects.

        Offset
        :   Distance to offset the curve from the surface.

        Absolute Offset
        :   Applies a fixed offset (does not scale by the curve radius).

        Only First
        :   Only uses the start of the stroke for the depth.

        Plane
        :   The orientation plane to draw on, available when *Only First* is enabled.

            Normal to Surface:
            :   Draws aligned to the surface.

            Tangent to Surface:
            :   Draws perpendicular to the surface.

            View:
            :   Draws aligned to the viewport.

Curve 2D
:   Project the curve on the Z axis.

As NURBS
:   Draw curves as a NURBS curve with Bézier knot mode, instead of a Bézier curve.
user: Show practical ways to work with Motion Blur in a Blender add-on or script – include code.

assistant: # Motion Blur

Blender’s animations are by default rendered as a sequence of *perfectly still* images.
While great for stop-motion and time-lapses, this is unrealistic, since fast-moving
objects do appear to be blurred in the direction of motion,
both in a movie frame and in a photograph from a real-world camera.

[image reference removed]

Motion blur example.
([blend-file](https://archive.blender.org/wiki/2015/uploads/0/03/Blender2.65_motion_blur.blend))

Position
:   Controls at what point the shutter opens in relation to the current frame.

    Start on Frame:
    :   Shutter is starting to open at the current frame.

    Center on Frame:
    :   Shutter is fully opened at the current frame.

    End on Frame:
    :   Shutter is fully closed at the current frame.

Shutter
:   Time (in frames) between when the shutter starts to open and fully closed.
    For example, shutter time 1.0 blurs over the length of 1 frame.

Rolling Shutter
:   Creates a [Rolling Shutter](../../../glossary/index.html#term-Rolling-Shutter) effect.

    None:
    :   No rolling shutter effect.

    Top-Bottom:
    :   Renders rolling shutter from the top of the image to the bottom.

Rolling Shutter Duration
:   Controls balance between pure rolling shutter effect (if the value is zero)
    and pure motion blur effect (if the value is one).
user: Provide the full official documentation entry for Interface, preserving all code examples.

assistant: Name
:   By default, modifiers are named after their function, but this can be changed.

Mute
:   Click the checkbox in a modifier’s header to disable it.

Delete
:   Click the cross in a modifier’s header to delete it.

Influence
:   Lets you blend between the original curve and the modified one.

Restrict Frame Range
:   Start/End
    :   The frame on which the modifier’s effect starts/ends.

    Blend In/Out
    :   The number of frames, relative the start/end values above, it takes the modifier to fade in/out.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Consider a node setup for green screen removal, using
a [Color Key](color_key.xhtml):

[image reference removed]

Often, lighting is uneven across the backdrop.

[image reference removed]

Example from the [Mango Open Movie](https://mango.blender.org/), Tears of Steel.

That can result in a bad matte.

[image reference removed]

Example of a poor mask: Some of the backdrop is opaque,
and some parts of the gun in the foreground are transparent.

If you increase the tolerances on the Color Key node, it will accept
more shades of green to mask out. But it may also incorrectly mask out more of
the foreground.

Instead of increasing the range of accepted shades to be masked out,
the Keying Screen node lets you change what shade of green (or other color) to used
for different parts of the image.

Start in the [Movie Clip Editor](../../../editors/clip/index.xhtml).
Open the Sidebar region and Toolbar to show tracking configuration.
Tracks used for gradients are not useful for camera solving, because they do not track well.
So create a new object track in the *Objects* selector.
Place tracking markers on the clip to sample different parts of the backdrop.

[image reference removed]

These tracks may be tracked or moved manually, so gradients can be updated
over time. If the marker is not enabled for a frame, it will not be used creating
the gradient. (Such as the red-colored marker on the arm in the screenshot above)

Once the tracks are created, add the node to your compositing setup,
and select the tracking object used for the backdrop.

[image reference removed]

Node configuration with *Keying Screen*’s generated gradient
plate connected to the Color input of the Keying node.

[image reference removed]

Gradient plate generated by *Keying Screen*.

The resulting image now has a better matte.

[image reference removed]
user: Provide the full official documentation entry for GeometryNodeInputMeshIsland(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInputMeshIsland(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.GeometryNodeInputMeshIsland(*GeometryNode*)
:   Retrieve information about separate connected regions in a mesh

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for face.skin_eye, preserving all code examples.

assistant: Implements a skin system [parent controller](skin.html#rigify-rigs-skin-skin-parents) that manages
two skin chains for the top and bottom eyelids in addition to generating the eye rotation mechanism.

The rig must have two child skin chains with names tagged with `.T` and `.B` symmetry
to mark the top and bottom eyelid, which are connected at their ends forming eye corners.
The chains are rigged to follow the surface of the eye and twist to its normal.

In addition, it creates target controls for aiming the eye, including a master control shared by
all eyes under the same parent rig. The eyelids are rigged to follow the movement of the eyeball
with adjustable influence.

Eyeball and Iris Deforms
:   Generates deform bones for the eyeball and the iris, the latter copying XZ scale from
    the eye target control. The iris is located at the tail of the ORG bone.

Eyelid Detach Option
:   Generates a slider to disable the mechanism that keeps eyelid controls stuck to the surface of the eye.

Split Eyelid Follow Slider
:   Generates two separate sliders for controlling the influence of the eye rotation on X and Z eyelid motion.

Eyelids Follow Default
:   Depending on *Split Eyelid Follow Slider*, specifies the default values for the split follow sliders,
    or fixed factors to be multiplied with the single common follow influence slider value.
user: How do I use Force in Blender? Include parameters, examples, warnings and best practices.

assistant: # Force

[image reference removed]

Force field visualization.

The *Force* field is the simplest of the fields. It gives a constant force away from
(positive strength) or towards (negative strength) the object’s origin.
user: Explain Curvature 3D in complete detail according to the official Blender documentation.

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]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_color_curvature-3d_example.png)

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

assistant: # MovieTrackingTracks(bpy_struct)

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

*class* bpy.types.MovieTrackingTracks(*bpy_struct*)
:   Collection of movie tracking tracks

    active
    :   Active track in this tracking data object. Deprecated, use objects[name].tracks.active

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

    new(*\**, *name=''*, *frame=1*)
    :   Create new motion track in this movie clip

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – Name of new track
            - **frame** (*int in* *[**0**,* *1048574**]**,* *(**optional**)*) – Frame, Frame number to add track on

        Returns:
        :   Newly created track

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

    *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 PHYSICS_UL_dynapaint_surfaces(UIList): syntax, arguments, return values, common patterns.

assistant: # PHYSICS_UL_dynapaint_surfaces(UIList)

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

*class* bpy.types.PHYSICS_UL_dynapaint_surfaces(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

    *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 Editing Meta Objects in a Blender add-on or script – include code.

assistant: # Editing Meta Objects

In addition to having several meta objects in a same family,
you can also have several meta primitives in a single object (just add some more while in Edit Mode).
Each will be an element, with its own shape, editing rings (in the viewport), and settings.
user: Explain Blender 5.0 Reference Manual in complete detail according to the official Blender documentation.

assistant: # Blender 5.0 Reference Manual

Welcome to the manual for [Blender](https://www.blender.org),
the free and open source 3D creation suite.

This site can be used offline:

- [Download the manual as web pages (HTML)](blender_manual_html.zip)
- [Download the manual in an e-book format (EPUB)](blender_manual_epub.zip)
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`XrActionMap.actionmap_items`](bpy.types.XrActionMap.html#bpy.types.XrActionMap.actionmap_items "bpy.types.XrActionMap.actionmap_items") - [`XrActionMapItems.find`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.find "bpy.types.XrActionMapItems.find") - [`XrActionMapItems.new`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.new "bpy.types.XrActionMapItems.new") - [`XrActionMapItems.new_from_item`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.new_from_item "bpy.types.XrActionMapItems.new_from_item") | - [`XrActionMapItems.new_from_item`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.new_from_item "bpy.types.XrActionMapItems.new_from_item") - [`XrActionMapItems.remove`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.remove "bpy.types.XrActionMapItems.remove") - [`XrSessionState.action_binding_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_binding_create "bpy.types.XrSessionState.action_binding_create") - [`XrSessionState.action_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_create "bpy.types.XrSessionState.action_create") |
user: Give a detailed overview of Mouse Clicks: syntax, arguments, return values, common patterns.

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]

`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]

`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]

`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]

`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: Give a detailed overview of Spline IK Constraint: syntax, arguments, return values, common patterns.

assistant: # Spline IK Constraint

The *Spline IK* constraint fits a chain of bones to the shape of a
[Curve](../../../modeling/curves/introduction.xhtml).
It’s particularly well suited for rigging flexible body parts such as tails, tentacles,
and spines, as well as inorganic objects such as ropes.
user: Show practical ways to work with Expand Mask by Normals in a Blender add-on or script – include code.

assistant: Expand a mask, following the curvature of the surface.
This operator uses the same internal operator as [Expand](#bpy-ops-sculpt-expand)
meaning all the shortcuts and functionality works the same as that tool.

This operator is especially useful for hard surface sculpting.
user: Show practical ways to work with Writing a Good Commit Message in a Blender add-on or script – include code.

assistant: When making changes to the manual that directly relate to a specific commit (change) in Blender, it is helpful to make
the title of the commit the same as the commit made to Blender. It is requested that you include the commit hash of
the commit made to the Blender source code.

For example, the commit [rBM8473](https://developer.blender.org/rBM8473) includes a descriptive indicative of the
changes made along with the hash `rBa71d2b260170`. The hash can be extracted from the URL provided in the
Documentation task for a specific upcoming release.

---

Other more general changes do not have to follow the above policy however, it is still important to make the
description clear about what changes you made and why. It can be helpful to prefix the commit title with a prefix word
such as `Cleanup:` or `Fix:` when you are making general cleanups or fixes respectively.

Writing good commit messages helps administrators keep track of changes made and ensures all new features are properly
documented.
user: How do I use MeshLoops(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MeshLoops(bpy_struct)

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

*class* bpy.types.MeshLoops(*bpy_struct*)
:   Collection of mesh loops

    add(*count*)
    :   add

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Count, Number of loops to add

    *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 Frizz Hair Curves in a Blender add-on or script – include code.

assistant: # Frizz Hair Curves

The *Frizz Hair Curves* node introduces small random displacements along hair curves to create
a frizzy or irregular look.
It is commonly used to add natural variation to grooms by breaking up overly smooth or uniform
strand shapes.
user: Show practical ways to work with Warning Node in a Blender add-on or script – include code.

assistant: # Warning Node

[image reference removed]

Outputs a custom message that can be referenced in the
[Warnings](../../modifiers/geometry_nodes.xhtml#modifiers-geometry-nodes-warnings) panel of the Geometry Nodes Modifier.

This allows node groups to communicate expectations about input values.

By default, warnings are propagated through all parent node groups.
However, this can be controlled using the [Warning Propagation](../../../interface/controls/nodes/node_editors.xhtml#bpy-types-node-warning-propagation) setting on each node.
user: Show practical ways to work with MetaBallElements(bpy_struct) in a Blender add-on or script – include code.

assistant: # MetaBallElements(bpy_struct)

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

*class* bpy.types.MetaBallElements(*bpy_struct*)
:   Collection of metaball elements

    active
    :   Last selected element

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

    new(*\**, *type='BALL'*)
    :   Add a new element to the metaball

        Parameters:
        :   **type** (enum in [Metaelem Type Items](bpy_types_enum_items/metaelem_type_items.html#rna-enum-metaelem-type-items), (optional)) – Type for the new metaball element

        Returns:
        :   The newly created metaball element

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

    remove(*element*)
    :   Remove an element from the metaball

        Parameters:
        :   **element** ([`MetaElement`](bpy.types.MetaElement.html#bpy.types.MetaElement "bpy.types.MetaElement"), (never None)) – The element to remove

    clear()
    :   Remove all elements from the metaball

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

assistant: Catmull-Clark subdivision rounds off edges, and often this is not what you want.
There are several solutions that allow you to control the subdivision.

### Weighted Edge Creases

Weighted edge creases for subdivision surfaces allows you to change the way
the *Subdivision Surface* modifier subdivides the geometry to give the edges a smooth or sharp appearance.

[image reference removed]

A subdivided cube with creased edges.

The crease weight of selected edges can be changed in the *Transform* panel, Sidebar of the 3D Viewport.
The scale-like dedicated tool `Shift`-`E` can also be used to adjust the crease weight.
A higher value makes the edge “stronger” and more resistant to the smoothing effect of subdivision surfaces.

### Edge Loops

[image reference removed]

Subdivision Level 2 cube, the same with an extra Edge Loop, and the same with six extra Edge Loops.

The *Subdivision Surface* modifier demonstrates why good, clean topology is so important.
As you can see in the figure, it has a drastic effect on a default cube.
Until you add in additional loops (with e.g. [Loop Cut and Slide](../../meshes/editing/edge/loopcut_slide.html#bpy-ops-mesh-loopcut-slide)),
the shape is almost unrecognizable as a cube.

A mesh with deliberate topology has good placement of edge loops, which allow the placement of more loops
(or their removal) to control the sharpness/smoothness of the resultant mesh.
user: Show practical ways to work with Clipping Region in a Blender add-on or script – include code.

assistant: Allows you to define a clipping region to limit the 3D Viewport display to a portion of 3D space.
It can assist in the process of working with complex models and scenes.

Once activated, you have to draw a rectangle with the mouse.
It becomes a clipping volume of four planes:

- A right-angled [parallelepiped](https://en.wikipedia.org/wiki/Parallelepiped)
  (of infinite length) if your view is orthographic.
- A rectangular-based pyramid (of infinite height) if your view is in perspective.

Once clipping is used, you will only see what’s inside the volume you defined.
Tools such as paint, sculpt, selection, transform snapping, etc.
will also ignore geometry outside the clipping bounds.

To delete this clipping, press `Alt`-`B` again.

### Example

Region/Volume clipping.

|  |  |  |
| --- | --- | --- |
| ../../../_images/editors_3dview_navigate_regions_border1.png   Selecting a region. | ../../../_images/editors_3dview_navigate_regions_border2.png   Region selected. | ../../../_images/editors_3dview_navigate_regions_border3.png   View rotated. |

The *Region/Volume clipping* image shows an example of using the clipping tool with a cube.
Start by activating the tool with `Alt`-`B`.
This will generate a dashed cross-hair cursor.
Click with the `LMB` and drag out a rectangular region.
Now clipping is applied against that region in 3D space.
Use the `MMB` to rotate
the view and you will see that only what is inside the clipping volume is visible.
All the editing tools still function as normal, but only within the clipping volume.

The dark gray area is the clipping volume itself.
Once clipping is deactivated with another `Alt`-`B`,
all of 3D space will become visible again.
user: Provide the full official documentation entry for Guides, preserving all code examples.

assistant: Grid
:   Show the grid.

Over Image
:   Show the grid on top of the image rather than behind it.

Grid Shape Source
:   How the row and column counts are determined.

    Dynamic:
    :   The grid starts at 8×8 cells that are automatically subdivided further as you zoom in.

    Fixed:
    :   The row and column counts are fixed and can be configured manually.

    Pixel:
    :   Each grid cell matches one image pixel.

Fixed Subdivisions X, Y
:   Number of columns/rows in the grid.

Tiles X, Y
:   The number of [UDIM](../../modeling/meshes/uv/workflows/udims.html)
    tile grids to display in each cardinal direction.
user: Show practical ways to work with ColorRampElement(bpy_struct) in a Blender add-on or script – include code.

assistant: # ColorRampElement(bpy_struct)

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

*class* bpy.types.ColorRampElement(*bpy_struct*)
:   Element defining a color at a position in the color ramp

    alpha
    :   Set alpha of selected color stop

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

    color
    :   Set color of selected color stop

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0)

    position
    :   Set position of selected color stop

        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: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The Video Sequencer allows you to place images, videos, sounds, and scenes
on a timeline and combine them into a new video. This section only describes its UI;
to read more about its usage, see the [Video Editing](../../video_editing/index.xhtml) section.
user: Explain UV Options in complete detail according to the official Blender documentation.

assistant: Live Unwrap
:   Continuously unwraps the selected UV islands while transforming pinned vertices.
    Note, this is different than the [Live Unwrap](../tools/tool_settings.xhtml#bpy-types-toolsettings-use-edge-path-live-unwrap)
    option in the 3D Viewport.

Round to Pixels
:   During UV transforms, you can use Round to Pixels to help with matching features in the image
    or ensure your UVs have precise horizontal, vertical or diagonal alignment.

    Note that Round to Pixels is applied after any snapping modes.

    Disabled:
    :   UVs will not be rounded.

    Corner:
    :   Will force the UVs to round to the corner of the nearest pixel of an image if loaded.

    Center:
    :   Will force the UVs to round to the center of the nearest pixel of an image if loaded.

Constraining to Image Bounds
:   For standard textures, this option prevents UVs from being moved outside the 0 to 1 UV range.
    For [UDIMs](workflows/udims.xhtml) textures,
    this option prevents UVs from being moved outside the nearest UDIM tile.
user: Provide the full official documentation entry for Displace Modifier, preserving all code examples.

assistant: # Displace Modifier

The *Displace* modifier displaces vertices in a mesh based on the intensity of a texture.
Either procedural or image textures can be used.

The displacement can be along a particular local axis, along the vertex normal,
or the separate RGB components of the texture can be used to displace vertices in the local X,
Y and Z directions simultaneously (sometimes referred to as *Vector Displacement*).
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: See below for the result of using *Shear* on a number of different elements.

[image reference removed]

The effects of a Shear transform with different Pivot Points.

The three frames of the image above show the effects of shearing
on the selected vertices when the pivot point is altered.
In middle frame, the [Pivot Point](../../../../../editors/3dview/controls/pivot_point/index.xhtml)
is set to *Median Point* and the mouse was moved to the left during the transform.
In right frame, the *Pivot Point* is set to the 3D cursor which is located above the mesh.
When the mouse is moved to the left during a *Shear* transform,
the selected vertices are moved to the right as they are below the horizontal axis.

[image reference removed]

The effects of a Shear transform on objects with different Pivot Points.