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

assistant: # Is Spline Cyclic Node

[image reference removed]

The *Is Spline Cyclic* controls whether each of the curve splines start and endpoints form a connection.
Its output corresponds to the built-in `cyclic` attribute on the curve spline domain.

The node to set this data is the [Set Spline Cyclic Node](../write/set_spline_cyclic.html).
user: Explain Assign parameters to functions in complete detail according to the official Blender documentation.

assistant: ```
import bpy
import functools

def print_message(message):
    print("Message:", message)

bpy.app.timers.register(functools.partial(print_message, "Hello"), first_interval=2.0)
bpy.app.timers.register(functools.partial(print_message, "World"), first_interval=3.0)
```

bpy.app.timers.is_registered(*function*)
:   Check if this function is registered as a timer.

    Parameters:
    :   **function** (*Callable**[**[**]**,* *float* *|* *None**]*) – Function to check.

    Returns:
    :   True when this function is registered, otherwise False.

    Return type:
    :   bool

bpy.app.timers.register(*function*, *\**, *first_interval=0*, *persistent=False*)
:   Add a new function that will be called after the specified amount of seconds.
    The function gets no arguments and is expected to return either None or a float.
    If `None` is returned, the timer will be unregistered.
    A returned number specifies the delay until the function is called again.
    `functools.partial` can be used to assign some parameters.

    Parameters:
    :   - **function** (*Callable**[**[**]**,* *float* *|* *None**]*) – The function that should called.
        - **first_interval** (*float*) – Seconds until the callback should be called the first time.
        - **persistent** (*bool*) – Don’t remove timer when a new file is loaded.

bpy.app.timers.unregister(*function*)
:   Unregister timer.

    Parameters:
    :   **function** (*Callable**[**[**]**,* *float* *|* *None**]*) – Function to unregister.
user: Give a detailed overview of Export: syntax, arguments, return values, common patterns.

assistant: ### General

Format: ASCII
:   Formats the file using the simple a ASCII format.
    This option might be helpful if the program that
    will later import the file does not support the binary file format.

Include: Selected Only
:   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.

Forward Axis, Up Axis
:   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

UV Coordinates
:   Write out the active UV layers coordinates from Blender.

Vertex Normals
:   Write out Blender’s face and vertex normals (depending on the faces smooth setting).

    Mostly this isn’t needed since most applications will calculate their
    own normals but to match Blender’s normal map textures you will need to write these too.

Vertex Colors
:   The color space that the color data in the ply-file was saved in.

    None:
    :   Does not import vertex color data.

    sRGB:
    :   Vertex colors in the file are in sRGB [Color Space](../../glossary/index.xhtml#term-Color-Space)

    Linear:
    :   Vertex colors in the file are in Linear [Color Space](../../glossary/index.xhtml#term-Color-Space)

Triangulated Mesh
:   All [N-gons](../../glossary/index.xhtml#term-N-gon) with four or more vertices will be triangulated.
    Meshes in the scene will not be affected.
    Behaves like [Triangulate Modifier](../../modeling/modifiers/generate/triangulate.xhtml) with the following settings:

    - N-gon Method: “Beauty”
    - Quad-method: “Shortest Diagonal”
    - Min vertices: 4

Apply Modifiers
:   Export objects using the evaluated mesh, meaning the resulting mesh after all
    [Modifiers](../../modeling/modifiers/index.xhtml) have been calculated.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Mesh
:   A geometry containing the mesh with a UV map for sampling.

Value
:   A field to evaluate on the target *Mesh* geometry for later sampling at the surface positions.

UV Map
:   The mesh UV map to sample, evaluated on the *Mesh* input. Should not have overlapping faces.

Sample UV
:   The coordinates to sample within the UV map.
user: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: ### General

### Unique

Height
:   Determines the range of influence of the brush above the brush plane.
    Increasing the height affects vertices farther above the plane.

Depth
:   Determines the range of influence of the brush below the brush plane.
    Increasing the depth affects vertices farther below the plane.

Inversion Mode
:   Determines the behavior of the brush when inverted.

    Invert Displacement
    :   When inverted, the brush displaces vertices away from the brush plane, resulting in increased contrast.

    Swap Height and Depth
    :   When inverted, the roles of the *Height* and *Depth* parameters are exchanged.

        For example, if *Height* is set to 0.7 and *Depth* to 0.3, inverting the brush causes the roles of these
        parameters to be exchanged, resulting in an effective *Height* of 0.3 and *Depth* of 0.7.

Stabilize Normal
:   Controls the stability of the brush plane’s orientation. The normal of the plane is averaged over the last few
    stroke steps, with the number of steps and blending factor determined by the parameter’s value.

    When set to 0, the brush reacts immediately to changes in the in surface orientation.

    When set to 1, the plane’s orientation remains constant throughout the stroke.

    Intermediate values provide a gradual transition between these behaviors, resulting in a weighted moving average of
    plane normals.

Stabilize Plane
:   Controls the stability of the brush plane’s position. Similar to *Stabilize Normal*, it works by averaging the
    position over the previous stroke steps.

    Each position is calculated as the interpolated between the unstabilized position and its projection onto the plane
    of the previous stroke step.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

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

UV Map
:   Name of the UV map to derive normal mapping tangents from. When chained with an Image Texture node,
    this UV map should be the same as the UV map used to map the texture.
user: What is Who uses Blender? and how is it used in Blender Python scripting?

assistant: Blender has a wide variety of tools making it suitable for almost any sort of media production. Professionals,
hobbyists, and studios around the world use it for creating animations, game assets, motion graphics, TV shows,
concept art, story-boarding, commercials, and feature films.

Check out the [User Stories page](https://www.blender.org/get-involved/user-stories/)
on the Blender website for more examples.
user: Give a detailed overview of Smooth: syntax, arguments, return values, common patterns.

assistant: The *Smooth* operator blends the weights of selected vertices based on the average of adjacent vertices,
creating smoother transitions in weight painting. This operator is useful for refining weight distributions,
improving deformation in rigging, and eliminating abrupt transitions between vertex weights.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) about how subsets are defined.

Factor
:   Controls the amount of blending toward the average weight of **connected** vertices.

    - A *Factor* of 0.0 preserves the original weights.
    - A *Factor* of 1.0 fully adopts the calculated average weight.
    - Values between 0.0 and 1.0 blend the weights proportionally.

Iterations
:   Sets how many times the smoothing operation is repeated.
    Higher values produce smoother results but may introduce unwanted artifacts in fine details.

Expand/Contract
:   Adjusts the smoothing influence by expanding or contracting the selection:

    - Positive values expand the selection to include neighboring vertices.
    - Negative values contract the selection to focus on a smaller subset of vertices.

### Examples

Example: Single Selected Vertex

Consider a single selected vertex connected to four unselected vertices.
The unselected vertices have weights: 1, 0, 0, and 0.
The average weight of the unselected vertices is: \((1 + 0 + 0 + 0) / 4 = 0.25\)

If the *Factor* is:

- 0.0: The selected vertex retains its original weight.
- 1.0: The selected vertex adopts the calculated average weight (0.25).
- Between 0 and 1: The vertex’s weight gradually shifts toward 0.25, blending proportionally.

[image reference removed]

Single vertex select with a *Factor* of 1.0.

Example: Multiple Selected Vertices

When multiple vertices are selected,
the *Smooth* operator applies calculations to each vertex based on its adjacent unselected vertices.

For example:

- A vertex connected to three unselected vertices with weights \((1, 0, 0)\) averages to \(0.333\).
- A vertex connected to one unselected vertex with weight 1 averages to \(1.0\).
- A vertex connected only to unselected vertices with weights \((0, 0, 0)\)
  remains unchanged with an average weight of \(0.0\).

These blended results depend on the *Factor* value.

[image reference removed]

Three selected vertices with a *Factor* of 1.0.

Example: Edge Loop Smoothing

In a practical use case, selecting a middle edge loop allows
the operator to blend weights between adjacent areas. For example:

- The edge loop has two unselected adjacent vertices on either side, with weights \(1\) and \(0\).
- The average weight is \((1 + 0) / 2 = 0.5\).
- Applying the *Smooth* operator with *Factor* set to 1.0 will turn the edge loop green,
  creating a smooth blend between the “hot” (left) and “cold” (right) sides.

[image reference removed]

Center edge loop of vertices selected with a *Factor* of 1.0.
user: Provide the full official documentation entry for Linked Duplicate, preserving all code examples.

assistant: Creates copies of the selected strips, reusing any actions they reference.
Editing the keyframes in a copied strip therefore also affects the original
(and vice versa). Blender warns you about this by highlighting the other strip in red.

[image reference removed]

Linked duplicated strip being edited.
user: How do I use Mesh Volumes in Blender? Include parameters, examples, warnings and best practices.

assistant: Meshes used for volume render should be closed and [Manifold](../../../glossary/index.xhtml#term-Manifold).
That means that there should be no holes in the mesh.
Each edge must be connected to exactly two faces
such that there are no holes or T-shaped faces
where three or more faces are connected to an edge.

Normals must point outside for correct results.
The normals are used to determine if a ray enters or exits a volume,
and if they point in a wrong direction, or there is a hole in the mesh,
then the renderer is unable to decide what is the inside or outside of the volume.

These rules are the same as for rendering glass refraction correctly.
user: What is Snap Target and how is it used in Blender Python scripting?

assistant: Determines the target which the selection will be snapped to.

Increment:
:   Snaps to grid points. When in Orthographic view, the snapping increment changes depending on the zoom level.

    This option snaps to an imaginary grid that starts at the selection’s original location and has the same
    resolution as the viewport grid. In other words, it lets you move the selection in “increments” of the
    grid cell size.

Grid:
:   Snaps to the grid that’s displayed in the viewport.

Vertex:
:   Snaps to the vertex that’s closest to the mouse cursor.

Edge:
:   Snaps to the edge that’s closest to the mouse cursor.

Face:
:   Snaps to the surfaces of faces in mesh objects; This is useful for retopologizing.

Volume:
:   Snaps the selection to a depth that’s centered *inside* the object under the cursor.
    This is useful for positioning an [Armature](../../../animation/armatures/introduction.xhtml)
    bone so it’s centered inside a character’s arm, for example; the other snapping options
    would place it on the arm’s surface instead.

    While Blender also has [Volume objects](../../../modeling/volumes/introduction.xhtml), this option
    is not related to those.

Edge Center:
:   Snaps to the centerpoint of the edge that’s closest to the mouse cursor.

Edge Perpendicular:
:   Snaps to a specific point on the edge so that the line from the selection’s original location
    (indicated by a white cross) to its new location is perpendicular to that edge.
user: Show practical ways to work with Details in a Blender add-on or script – include code.

assistant: macOS uses “files” with the `.app` extension called *applications*.
These files are actually folders that appear as files in Finder.
In order to run Blender you will have to specify that path to the Blender executable inside this folder,
to get all output printed to the terminal.
You can start a terminal from Applications ‣ Utilities.
The path to the executable in the `.app` folder is `./Blender.app/Contents/MacOS/Blender`.

If you have Blender installed in the Applications folder, the following command can be used:

```
/Applications/Blender.app/Contents/MacOS/Blender
```

[image reference removed]

Starting Blender from a macOS console window.
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleAlphaModifier.name`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier.name "bpy.types.LineStyleAlphaModifier.name") |
user: Give a detailed overview of Installation on macOS: syntax, arguments, return values, common patterns.

assistant: # Installation on macOS

This guide covers the following topics:

1. [Installing Dependencies](#installing-dependencies)
2. [Downloading the Repository](#downloading-the-repository)
3. [Setting up the Build Environment](#setting-up-the-build-environment)
user: Provide the full official documentation entry for Mask Strip, preserving all code examples.

assistant: # Mask Strip

The Mask strip generates a mask image from the selected mask data-block generated
in the [Movie Clip Editor](../../../../movie_clip/masking/index.html).
This works similar to the [Mask Node](../../../../compositing/types/input/mask.html)
but without the options available for finer control.
The mask image is always generated at the render resolution,
scaling along with different proxy levels.
user: What is NormalEditModifier(Modifier) and how is it used in Blender Python scripting?

assistant: # NormalEditModifier(Modifier)

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

*class* bpy.types.NormalEditModifier(*Modifier*)
:   Modifier affecting/generating custom normals

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    mix_factor
    :   How much of generated normals to mix with existing ones

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

    mix_limit
    :   Maximum angle between old and new normals

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

    mix_mode
    :   How to mix generated normals with existing ones

        - `COPY`
          Copy – Copy new normals (overwrite existing).
        - `ADD`
          Add – Copy sum of new and old normals.
        - `SUB`
          Subtract – Copy new normals minus old normals.
        - `MUL`
          Multiply – Copy product of old and new normals (not cross product).

        Type:
        :   enum in [`'COPY'`, `'ADD'`, `'SUB'`, `'MUL'`], default `'COPY'`

    mode
    :   How to affect (generate) normals

        - `RADIAL`
          Radial – From an ellipsoid (shape defined by the boundbox’s dimensions, target is optional).
        - `DIRECTIONAL`
          Directional – Normals ‘track’ (point to) the target object.

        Type:
        :   enum in [`'RADIAL'`, `'DIRECTIONAL'`], default `'RADIAL'`

    no_polynors_fix
    :   Do not flip polygons when their normals are not consistent with their newly computed custom vertex normals

        Type:
        :   boolean, default False

    offset
    :   Offset from object’s center

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

    target
    :   Target object used to affect normals

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

    use_direction_parallel
    :   Use same direction for all normals, from origin to target’s center (Directional mode only)

        Type:
        :   boolean, default True

    vertex_group
    :   Vertex group name for selecting/weighting the affected areas

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Select Mirror

Select Mirror flips a selection to the opposite side of the mesh.

Axis
:   Choose on which axis the selection will occur. The axis is based on the meshes origin.
    Therefore, if the origin is not centered within the mesh, the selection will have varying results.

Extend
:   The new selection will include the mirrored selection as well as the original.

[image reference removed]

(From left to right) initial selection, after Select Mirror on the X axis, with Extend.
user: What is Spline Parameter Node and how is it used in Blender Python scripting?

assistant: # Spline Parameter Node

[image reference removed]

The *Spline Parameter* node outputs how far along each spline a control point is.
The *Factor* output is different from dividing the index by the total number of control points,
because the control points might not be equally spaced along the curve.

The first value is zero, so the output corresponds to the length at the control point rather than
including the length of the following segment.

When used on the spline domain, the node outputs the portion of the total length of the curve (including
all splines) has been traversed at the start of each spline. The order of the curve’s splines is visible
in the [Spreadsheet Editor](../../../../editors/spreadsheet.xhtml).
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Start
:   Position of the first control point.

End
:   Position of the second control point.
    This is only available in the *Points* mode.

Direction
:   Direction the line is going in.
    The length of this vector does not matter.
    This is only available in the *Direction* mode.

Length
:   Length of the line.
    This is only available in the *Direction* mode.
user: What is GeometryNodeMaterialSelection(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeMaterialSelection(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.GeometryNodeMaterialSelection(*GeometryNode*)
:   Provide a selection of faces that use the specified material

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

assistant: # LineStyleThicknessModifiers(bpy_struct)

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

*class* bpy.types.LineStyleThicknessModifiers(*bpy_struct*)
:   Thickness modifiers for changing line thickness

    new(*name*, *type*)
    :   Add a thickness modifier to line style

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the thickness modifier (not unique)
            - **type** (enum in [Linestyle Thickness Modifier Type Items](bpy_types_enum_items/linestyle_thickness_modifier_type_items.html#rna-enum-linestyle-thickness-modifier-type-items)) – Thickness modifier type to add

        Returns:
        :   Newly added thickness modifier

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

    remove(*modifier*)
    :   Remove a thickness modifier from line style

        Parameters:
        :   **modifier** ([`LineStyleThicknessModifier`](bpy.types.LineStyleThicknessModifier.html#bpy.types.LineStyleThicknessModifier "bpy.types.LineStyleThicknessModifier"), (never None)) – Thickness modifier to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of GeometryNodeScaleElements(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeScaleElements(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.GeometryNodeScaleElements(*GeometryNode*)
:   Scale groups of connected edges and faces

    domain
    :   Element type to transform

        - `FACE`
          Face – Scale individual faces or neighboring face islands.
        - `EDGE`
          Edge – Scale individual edges or neighboring edge islands.

        Type:
        :   enum in [`'FACE'`, `'EDGE'`], default `'FACE'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Show & Hide from the Blender manual or Python API, including usage steps and snippets.

assistant: Some very common hotkey operators to control the visibility based on face sets.
These are not part of any menu and have to be used via the shortcuts.
More visibility operators can be found in the [Face Sets Menu](face_sets.xhtml)
and the Pie Menu shortcut `Alt`-`W`. (Since visibility is often toggled via face sets.)

Box Hide
:   Draw a box to hide faces of a mesh.

Box Show
:   Draw a box to reveal hidden faces.
    This works similar to the [Box Select](../../../interface/selecting.xhtml#tool-select-box) tool.

Toggle Visibility `Shift`-`H`
:   Hide all face sets except the active one (under the cursor).
    If face sets are already hidden, then this operator will show everything.

Hide Active Face Set `H`
:   Hide the face set under the cursor. Press `Shift`-`H` afterwards to show everything.

Show All `W`, `Alt`-`H`
:   Reveal all hidden geometry.

Invert Visible
:   Hides all visible geometry and makes all hidden geometry visible.

Hide Masked
:   Hides all masked vertices.

Grow/Shrink Visibility `PageUp`, `PageDown`
:   Grows or shrinks the visible area of the mesh along its surface.
user: How do I use Start & End Mapping in Blender? Include parameters, examples, warnings and best practices.

assistant: Factor Start, End
:   The percentages along the length of the curve where the geometry should start
    and end. By default, these are set to 0 and 1, making the geometry cover the full length;
    but if you change them to 0.5 and 0.75, the geometry will only cover the third quarter
    of the curve.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_bevel.png   A curve with Factor Start set to 0 and End to 1. | ../../../_images/modeling_curves_properties_geometry_bevel-start-end-factor.png   Factor End changed to 0.6. |

Mapping Start, End
:   How to map the *Factor Start, End* percentages to positions on the curve.

    Resolution:
    :   Only count control points, disregarding the lengths of the spline segments (pieces of
        spline between two control points). If a spline has three control points and *Factor Start*
        is set to 0.5, the geometry will always start at the second control point,
        even if its distances to the first and third control points are completely different.

    Segments:
    :   Calculate an approximate percentage along the length of the spline by assuming that
        all the subdivisions within each segment are evenly distributed.

    Spline:
    :   Calculate an accurate percentage along the length of the spline.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

There is no single optimal workflow for editing your video projects that fits every case.
Although there certainly are some specific use cases; e.g. tutorial editing,
wedding videos, …, some agreement exists about distinguishing four basic activities.

1. Montage: starting with your raw footage, you’ll have to deliver a coherent and fluent succession
   of strips that tell your story. Clips have to be rearranged, combined, split (cut) and trimmed.
2. Effects: these can be simple transition effects between strips, e.g.
   fade or full-fledged animations, e.g. rolling end credits.
3. Color grading: because your assembled timeline consists of different shots taken
   with different cameras under different lighting conditions, colors can vary widely between them.
   With color grading and color correcting you can harmonize the color perception.
4. Sound: this ranges from adding background music and voice-over to creating special
   sound effects and using third-party software such as Audacity.
user: Explain Camera in complete detail according to the official Blender documentation.

assistant: To tweak the stereo 3D parameters, select the camera in the Outliner.
In the Camera panel go to the Stereoscopy tab and change the *Convergence Distance*.

The viewport will respond in real-time to those changes allowing you to preview the current depth value of the scene.

[image reference removed]

Stereo convergence distance.
user: Explain Displace Geometry Node in complete detail according to the official Blender documentation.

assistant: # Displace Geometry Node

[image reference removed]

The *Displace Geometry* node moves geometry elements along a specified direction or vector,
offsetting their positions to create deformations or surface displacements.
It can be used to apply procedural surface detail, simulate wave-like motion, or modify
shapes based on fields such as textures or vertex attributes.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`PointCloud.attributes`](bpy.types.PointCloud.html#bpy.types.PointCloud.attributes "bpy.types.PointCloud.attributes") | - [`PointCloud.color_attributes`](bpy.types.PointCloud.html#bpy.types.PointCloud.color_attributes "bpy.types.PointCloud.color_attributes") |
user: Give a detailed overview of Denoise Node: syntax, arguments, return values, common patterns.

assistant: # Denoise Node

[image reference removed]

The Denoise node is used to denoise renders from [Cycles](../../../render/cycles/index.html)
and other ray tracing renderers. This helps to significantly reduce render time by
rendering with fewer samples.

It uses [Open Image Denoise](https://www.openimagedenoise.org/),
which transforms noisy images into clean images with machine learning.
user: What is Usage and how is it used in Blender Python scripting?

assistant: [image reference removed]

Curve Pen Preferences

The following preferences can be configured from:
Preferences ‣ Keymap ‣ 3D View ‣ Curve ‣ 3D View Tool: Edit Curve, Curve Pen.

Extrude Point
:   `LMB` click to add a new point connected to an existing point.

Extrude Handle Type
:   The [handle type](../structure.html#curve-bezier-handle-type) of the extruded points.
    Can be either *Vector* or *Auto*.
    However, the handle type switches to *Align* when handles are moved (See *Move Point*).

Delete Point
:   `Ctrl`-`LMB` click on an existing point to delete it.

Insert Point
:   `Ctrl`-`LMB` click on a [Curve Segment](../../../glossary/index.html#term-Curve-Segment) to insert a new control point between the two
    adjacent control points. `Ctrl`-`LMB` click and drag to control the handles of the inserted points.

Move Segment
:   `LMB` drag on a segment in between two control points to adjust the handles, changing the shape of the
    curve without affecting the location of any control points.

Select Point
:   `LMB` click to select a single point or handle at a time.

Move point
:   `LMB` drag to move existing points or handles. With an endpoint of a spline selected,
    click and drag on empty space to *Extrude Point* and move the handle at the same time.

Close Spline
:   Make the spline [Cyclic](../../../glossary/index.html#term-Cyclic) by clicking the endpoints consecutively.

Close Spline Method
:   The condition for *Close Spline* to activate.

    None:
    :   Turn off the Close Spline functionality.

    On Press:
    :   Close the spline on mouse down. With this option, you may click and drag to adjust the handles of the endpoint.

    On Click:
    :   Activate on mouse release. With this option, the *Close Spline* functionality will not be
        triggered on click and drag.

Toggle Vector
:   Double `LMB` click on a handle to switch handle between *Vector* and *Auto* handle types.
    Can be used to easily switch between sharp corners and smooth curves.

Cycle Handle Type
:   Double `LMB` click on the control point to cycle through all handle types.
user: How do I use AOVs(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # AOVs(bpy_struct)

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

*class* bpy.types.AOVs(*bpy_struct*)
:   Collection of AOVs

    add()
    :   add

        Returns:
        :   Newly created AOV

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

    remove(*aov*)
    :   Remove an AOV

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Run-Time Optimizations from the Blender manual or Python API, including usage steps and snippets.

assistant: When executing shaders, a special optimization is applied to Mix Shader nodes.
If Factor evaluates to 0 or 1, any nodes that are only reachable via the unused branch of the mix are not evaluated.

This can substantially reduce the performance cost of combining multiple materials
in one shader with a Color Attribute, texture, or other input used as a switch.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: The inputs of the node are dynamic. Some inputs are only available in certain operations.
For instance, the *Scale* input is only available in the *Scale* operator.

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

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

Scale
:   Input Scale \(s\).
user: Describe Short2Attribute(Attribute) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Short2Attribute(Attribute)

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

*class* bpy.types.Short2Attribute(*Attribute*)
:   Geometry attribute that stores 2D integer vectors

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Beztriple Keyframe Type Items in complete detail according to the official Blender documentation.

assistant: # Beztriple Keyframe Type Items

KEYFRAME:
:   Keyframe.

    Normal keyframe, e.g. for key poses.

BREAKDOWN:
:   Breakdown.

    A breakdown pose, e.g. for transitions between key poses.

MOVING_HOLD:
:   Moving Hold.

    A keyframe that is part of a moving hold.

EXTREME:
:   Extreme.

    An “extreme” pose, or some other purpose as needed.

JITTER:
:   Jitter.

    A filler or baked keyframe for keying on ones, or some other purpose as needed.

GENERATED:
:   Generated.

    A key generated automatically by a tool, not manually created.
user: Explain Removing Data-Blocks in complete detail according to the official Blender documentation.

assistant: As covered in [Life Time](#life-time), data-blocks are typically removed when they are no longer used.
They can also be manually *unlinked* or *deleted*.

Unlinking a data-block means that its user won’t use it anymore.
This can be achieved by clicking on the “X” icon next to a data-block’s name.
If you unlink a data-block from all of its users,
it will eventually be deleted by Blender as described above (unless it is a protected one).

Deleting a data-block directly erases it from the blend-file, automatically unlinking it from all of its users.
This can be achieved by `Shift`-`LMB` on the “X” icon next to its name.

Those two operations are also available in the context menu
when `RMB`-clicking on a data-block in the *Outliner*.
user: Show practical ways to work with Follow Track Constraint in a Blender add-on or script – include code.

assistant: # Follow Track Constraint

The *Follow Track* constraint makes an object imitate the movement of a
[motion tracking marker](../../../movie_clip/tracking/clip/marker.html). This makes the object appear at the
same position in the render as where the marker appears in the motion-tracked video.

By default, the object follows the 2D motion of the marker in the video on a plane in the 3D world.
However, it’s also possible to make the object follow the reconstructed 3D position of the marker.
The latter requires setting up at least eight markers and clicking [Solve Camera/Object Motion](../../../movie_clip/tracking/clip/editing/track.html#bpy-ops-clip-solve-camera).
user: Show practical ways to work with Linestyle Color Modifier Type Items in a Blender add-on or script – include code.

assistant: # Linestyle Color Modifier Type Items

ALONG_STROKE:
:   Along Stroke.

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: How do I use Shape in Blender? Include parameters, examples, warnings and best practices.

assistant: # Shape

These settings control the shape of hair curves for rendering.

Strand Shape
:   A shape parameter that controls the transition in thickness between the root and tip.
    Negative values make the primitive rounded more towards the top,
    the value of zero makes the primitive linear,
    and positive values make the primitive rounded more towards the bottom.

Diameter Root
:   Multiplier of the hair width at the root.

Tip
:   Multiplier of the hair width at the tip.

Radius Scale
:   Multiplier for the *Root* and *Tip* values. This can be used to change the thickness of the hair.

Close Tip
:   Sets the thickness at the tip to zero, even when using a nonzero tip multiplier.
user: What is Usage and how is it used in Blender Python scripting?

assistant: First define the base of the object by dragging with `LMB`.
Next, release `LMB` and move the mouse to define the height of the object.
Finally, click `LMB` to confirm the shape of the object.

You can use the following hotkeys to temporarily change a setting
(for as long as the key is held):

|  |  |
| --- | --- |
| `Ctrl` | Toggles snapping. |
| `Alt` | Toggles the *Origin* setting. |
| `Shift` | Toggles the *Aspect* setting. |
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Island Index
:   The index of each vertex’s island. Indices are decided based on the
    lowest vertex index contained in each island.

Island Count
:   The total number of mesh islands. This is a single value, and does not vary per element.
user: Provide the full official documentation entry for CurveProfilePoints(bpy_struct), preserving all code examples.

assistant: # CurveProfilePoints(bpy_struct)

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

*class* bpy.types.CurveProfilePoints(*bpy_struct*)
:   Collection of Profile Points

    add(*x*, *y*)
    :   Add point to the profile

        Parameters:
        :   - **x** (*float in* *[**-inf**,* *inf**]*) – X Position, X Position for new point
            - **y** (*float in* *[**-inf**,* *inf**]*) – Y Position, Y Position for new point

        Returns:
        :   New point

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

    remove(*point*)
    :   Delete point from the profile

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use MotionPathVert(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MotionPathVert(bpy_struct)

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

*class* bpy.types.MotionPathVert(*bpy_struct*)
:   Cached location on path

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

    select
    :   Path point is selected for editing

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Vector
:   The coordinates at which Gabor noise will be evaluated. The Z component is ignored in the 2D
    case. Defaults to *Generated* texture coordinates if the socket is left unconnected.

Scale
:   Scale of the Gabor noise.

Frequency
:   The rate at which the Gabor noise changes across space. This is different from the Scale input
    in that it only scales perpendicular to the Gabor noise direction.

Anisotropy
:   The directionality of Gabor noise. 1 means the noise is completely directional, while 0 means
    the noise is omnidirectional.

Orientation
:   The direction of anisotropic Gabor noise. This is an angle for the 2D case, while it is a unit
    direction vector for the 3D case.
user: How do I use NodeSocketVectorPercentage(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketVectorPercentage(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorPercentage(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type