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

assistant: ### Customized triangulation

One or many “single point spline” can be used to customize the triangulation of the filled-in curves.

[image reference removed]

This is the default behavior of the *Fill Curve* node applied to the star primitive.

[image reference removed]

Here, a single curve point is joined to the star primitive to customize the triangulation.

[image reference removed]

Here, 300 single curve point are joined to the star primitive to customize the triangulation.

### Group ID

The following figures display diverse application of the Group ID.

[image reference removed]

Here, the 4 curves share the same Group ID, resulting in 1 mesh island (default behavior).

[image reference removed]

Here, the 4 curves have different Group ID, resulting in 4 mesh islands.

[image reference removed]

Here, the 4 curves are seperated into two groups based on their positions, resulting in 2 mesh islands.
user: Describe SEQUENCER_FH_movie_strip(FileHandler) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SEQUENCER_FH_movie_strip(FileHandler)

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

*class* bpy.types.SEQUENCER_FH_movie_strip(*FileHandler*)
:   *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 ShaderNodeBsdfMetallic(ShaderNode), preserving all code examples.

assistant: # ShaderNodeBsdfMetallic(ShaderNode)

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

*class* bpy.types.ShaderNodeBsdfMetallic(*ShaderNode*)
:   Metallic reflection with microfacet distribution, and metallic fresnel

    distribution
    :   Light scattering distribution on rough surface

        - `BECKMANN`
          Beckmann.
        - `GGX`
          GGX.
        - `MULTI_GGX`
          Multiscatter GGX – GGX with additional correction to account for multiple scattering, preserve energy and prevent unexpected darkening at high roughness.

        Type:
        :   enum in [`'BECKMANN'`, `'GGX'`, `'MULTI_GGX'`], default `'BECKMANN'`

    fresnel_type
    :   Fresnel method used to tint the metal

        - `PHYSICAL_CONDUCTOR`
          Physical Conductor – Fresnel conductor based on the complex refractive index per color channel.
        - `F82`
          F82 Tint – An approximation of the Fresnel conductor curve based on the colors at perpendicular and near-grazing (roughly 82°) angles.

        Type:
        :   enum in [`'PHYSICAL_CONDUCTOR'`, `'F82'`], default `'PHYSICAL_CONDUCTOR'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Edges of Vertex Node in complete detail according to the official Blender documentation.

assistant: # Edges of Vertex Node

[image reference removed]

Selects a neighboring edge of a vertex and outputs its index.

This node is a bit special because it operates in two different domains.
First, it evaluates a *Weight* for each edge in the geometry.
Then, for each item in the context domain, it will:

- Pick a vertex from the geometry based on the *Vertex Index*.
- Find the edges connected to this vertex.
- Sort these edges by their associated weight.
- Pick an edge from the above sorted list based on the *Sort Index*,
  where 0 means the edge with the lowest weight,
  1 means the edge with the second-lowest weight and so on.
- Output the geometry-wide index of this edge.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Mode
:   Rectangle:
    :   Generate a rectangle-shaped curve with a width and a height.

    Parallelogram:
    :   Generate a rectangle with an offset for the different X values of the top and bottom edges.

    Trapezoid:
    :   Generate a trapezoid-shaped curve with a height, a width for the top and bottom, and an offset.

    Kite:
    :   Generate a kite shape with a width, and the top and bottom points distance from the X axis.

    Points:
    :   Generate a four point cyclic poly spline by inputting the position vectors directly.
user: Provide the full official documentation entry for Brush, preserving all code examples.

assistant: # Brush

The Brush type makes object apply paint on the canvas.

[image reference removed]

Brush main panel.

From the first brush panel you can define how brush affects canvas color surfaces.

Paint Color
:   Color of the paint.

Alpha
:   Defines brush alpha or visibility. Final wetness is also affected by alpha.

Wetness
:   Defines how “wet” new paint is. Wetness is visible on “Paint” surface “wetmap”.
    Speed of “Drip” and “Spread” effects also depends on how wet the paint is.

Absolute Alpha
:   This setting limits brush alpha influence.
    Without it, brush is “added” on surface over and over again each frame,
    increasing alpha and therefore influence of brush on canvas. In many cases however,
    it is preferred to not increase brush alpha if it already is on brushes level.

Erase Paint
:   Makes brush dissolve existing paint instead of adding it.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Creating a Slow-Motion Effect

Suppose you want to slow your strip down.
You need to affect the speed of the video clip without affecting the overall frame rate.
Select the clip and Add ‣ Effect ‣ Speed Control effect strip.

Choose the *Multiply* option in the Effect Strip panel in the Sidebar.
Set the Multiply Factor to be the factor by which you want to adjust the speed.
To cut the displayed speed by 50%, enter 0.5.
Now, a 275-frame clip will play at half speed, and thus display only the first 137 frames.

If you want the remaining frames to show in slow motion after the first set is displayed,
double the Length of the source strip
(since effects strip bounds are controlled by their source strips).
If you are using a speed factor other than 0.5 then use the formula:

`new_length = real_length / speed_factor`

That is it, set your render to animate (in this example) all 550 frames.

### Keyframing the Speed Control

[image reference removed]

Keyframing the Frame number.

To get even finer control over your clip timing, you can use curves!
While it is possible to keyframe the Multiply factor,
usually you want to keyframe the Frame number directly.

Choose the *Frame Number* option. You now have a Frame number field which you can keyframe.
If you want the strip to animate **at all** you will have to insert some keyframes,
otherwise it will look like a still. In most cases you will want to use the Graph editor view
to set the curve interpolation to Linear since the default Bézier will rarely be what you want.

### Changing Video Frame Rates

You can use the speed control to change the frame rate in frames per second (fps) of a video.
If you are rendering your video to a sequence set,
you can effectively increase or decrease the number of individual image files created,
by using a Multiply value less than or greater than one, respectively.

For example, if you captured a five-minute video at 30 fps and wanted to transfer that to film,
which runs at 24 fps, you would enter a Multiply Factor of 30/24, or 1.25
(and enable *Interpolation* frame blending to create a film blur effect).
Instead of producing `5 × 60 × 30 = 9000` frames,
Blender would produce `9000 / 1.25 = 7200 = 5 × 60 × 24` frames.
In this case, you set a *start* = 1 and *end* = 7200, set your Format output to `jpeg` 30fps,
and image files `0001.jpg` through `7200.jpg` would be rendered out,
but those images cover the entire 9000 frames. The image file `7200.jpg` is the same at frame 9000.
When you read those images back into your film blend-file at 24 fps, the strip will last exactly 5 minutes.
user: Give a detailed overview of Geometry: syntax, arguments, return values, common patterns.

assistant: 3D Markers to Mesh
:   See [3D Markers to Mesh](../editing/reconstruction.html#bpy-ops-clip-bundles-to-mesh).

Link Empty to Track
:   See [Link Empty to Track](../editing/reconstruction.html#bpy-ops-clip-track-to-empty).
user: Describe Nodes from the Blender manual or Python API, including usage steps and snippets.

assistant: Nodes should always have three headings inputs, properties and outputs with a note of absence if the node has none. At
the end of the page can be an optional example(s) section:

```
**********
World Node
**********

.. figure:: /images/render_shader-nodes_output_world_node.png
   :align: right

   The World node.

Introduction and general use case(s).

Inputs
======

This node has no inputs.

Properties
==========

This node has no properties.

Outputs
=======

This node has no outputs.

Example
=======
```
user: What is Grid Laplacian Node and how is it used in Blender Python scripting?

assistant: # Grid Laplacian Node

[image reference removed]

The *Grid Laplacian* node computes the Laplacian of a scalar voxel grid.
The Laplacian measures how a value at each voxel differs from the average
of its neighbors—essentially, how much the field “curves” or deviates locally.

Mathematically, the Laplacian is defined as the divergence of the gradient
of a scalar field. It is commonly used in physics and geometry for diffusion,
smoothing, curvature analysis, and solving partial differential equations.

For a scalar field \(f(x, y, z)\), the Laplacian \(\nabla^2 f\)
is given by:

\[\nabla^2 f = \nabla f =
\frac{\partial^2 f}{\partial x^2} +
\frac{\partial^2 f}{\partial y^2} +
\frac{\partial^2 f}{\partial z^2}\]

The Laplacian is positive where the field has a local minimum (value smaller
than its surroundings) and negative where it has a local maximum (value
larger than its surroundings).
user: Show practical ways to work with GPencilSculptGuide(bpy_struct) in a Blender add-on or script – include code.

assistant: # GPencilSculptGuide(bpy_struct)

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

*class* bpy.types.GPencilSculptGuide(*bpy_struct*)
:   Guides for drawing

    angle
    :   Direction of lines

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

    angle_snap
    :   Angle snapping

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

    location
    :   Custom reference point for guides

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

    reference_object
    :   Object used for reference point

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

    reference_point
    :   Type of speed guide

        - `CURSOR`
          Cursor – Use cursor as reference point.
        - `CUSTOM`
          Custom – Use custom reference point.
        - `OBJECT`
          Object – Use object as reference point.

        Type:
        :   enum in [`'CURSOR'`, `'CUSTOM'`, `'OBJECT'`], default `'CURSOR'`

    spacing
    :   Guide spacing

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

    type
    :   Type of speed guide

        - `CIRCULAR`
          Circular – Use single point to create rings.
        - `RADIAL`
          Radial – Use single point as direction.
        - `PARALLEL`
          Parallel – Parallel lines.
        - `GRID`
          Grid – Grid allows horizontal and vertical lines.
        - `ISO`
          Isometric – Grid allows isometric and vertical lines.

        Type:
        :   enum in [`'CIRCULAR'`, `'RADIAL'`, `'PARALLEL'`, `'GRID'`, `'ISO'`], default `'CIRCULAR'`

    use_guide
    :   Enable speed guides

        Type:
        :   boolean, default False

    use_snapping
    :   Enable snapping to guides angle or spacing options

        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](#bpy.types.GPencilSculptGuide.type "bpy.types.GPencilSculptGuide.type")
user: Explain Notes in complete detail according to the official Blender documentation.

assistant: It is possible that this node will put out a value set that has values beyond the normal range,
i.e. values greater than one and less than zero.
If you will be using the output to mix with other images in the normal range,
you should clamp the values using the Map Value node (with the Min and Max enabled),
or put through a Color Ramp node (with all normal defaults).

[[image reference removed]](../../../../_images/compositing_types_color_bright-contrast_clamp-values.png)

Clamp the values to normal range.

Either of these nodes will scale the values back to normal range.
In the example image, we want to intensify the specular pass.
The bottom thread shows what happens if we do not clamp the values;
the specular pass has a value much less than one in the dark areas;
when added to the medium gray, it makes black. Passing the brightened image through either
the Map Value or the Color Ramp node produces the desired effect.
user: How do I use Using Blender From The Command Line in Blender? Include parameters, examples, warnings and best practices.

assistant: # Using Blender From The Command Line

The *Console Window*, also called a *Terminal*, is an operating system text window that displays
messages about Blender’s operations, status, and internal errors.

When Blender is manually started from a terminal,
Blender output is shown in the *Console Window* it is started from.

Use Cases:

- For [rendering animation](render.xhtml#command-line-render).
- For automation and batch processing which require launching Blender
  with different [arguments](arguments.xhtml#command-line-args).
- For Python development, to see the output of the `print()` function.
- If Blender exits unexpectedly, the messages may indicate the cause or error.
- When troubleshooting, to see the output of `--debug` messages.

See: [Launching from the Command Line](launch/index.xhtml#command-line-launch-index)
for specific instructions on launching Blender from the command line.
user: What is Replace Material Node and how is it used in Blender Python scripting?

assistant: # Replace Material Node

[[image reference removed]](../../../../_images/node-types_GeometryNodeReplaceMaterial.webp)

The *Replace Material* node swaps one material with another.
Replacing a material with this node is more efficient than creating a selection of all faces
with the old material with the [Material Selection Node](material_selection.html)
and then using the [Set Material Node](set_material.html).
user: How do I use Set Position Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Position Node

[image reference removed]

The *Set Position* node controls the location of each point, the same way as controlling
the `position` attribute.
If the input geometry contains instances, this node will affect the location of the origin of each instance.

The input node for this data is the [Position Node](../read/position.xhtml).
user: How do I use AssetTags(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # AssetTags(bpy_struct)

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

*class* bpy.types.AssetTags(*bpy_struct*)
:   Collection of custom asset tags

    new(*name*, *\**, *skip_if_exists=False*)
    :   Add a new tag to this asset

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name
            - **skip_if_exists** (*boolean**,* *(**optional**)*) – Skip if Exists, Do not add a new tag if one of the same type already exists

        Returns:
        :   New tag

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

    remove(*tag*)
    :   Remove an existing tag from this asset

        Parameters:
        :   **tag** ([`AssetTag`](bpy.types.AssetTag.html#bpy.types.AssetTag "bpy.types.AssetTag"), (never None)) – Removed tag

    *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 Mesh Filters in complete detail according to the official Blender documentation.

assistant: Applies a deformation to all vertices in the mesh at the same time.
Masking, auto-masking and visibility will be taken into account.

To use these operators, click and drag away from left to right
or from right to left for a negative effect.

Smooth
:   Smooths the positions of the vertices to either polish surfaces or remove volume from larger shapes.
    Especially useful to fix most of the artifacts of the voxel remesher.
    This filter works similar to the [Smooth](../brushes/smooth.html) brush.

Surface Smooth
:   Eliminates irregularities of the mesh by making the positions
    of the vertices more uniform while preserving the volume of the object.
    This filter works similar to the *Surface* deformation type of the
    [Smooth](../brushes/smooth.html) brush.

Inflate
:   Displaces vertices uniformly along their normal.
    This filter works similar to the [Inflate](../brushes/inflate.html) brush.

Relax Topology
:   Tries to create an even distribution of quads without deforming the volume of the mesh.
    This filter works the same as holding `Shift` with the
    [Slide Relax](../brushes/slide_relax.html) brush.

Relax Face Sets
:   This will remove the jagged lines visible after drawing or creating a face set.
    This filter works the same as holding `Shift` with the
    [Draw Face Set](../brushes/draw_facesets.html) brush.

Sharpen
:   Sharpens and smooths the mesh based on its curvature,
    resulting in pinching hard edges and polishing flat surfaces.
    Especially useful when sculpting hard surfaces and stylized models
    with creasing and flattening brushes.

Enhance Details
:   Increases the high frequency surface details of the mesh
    by intensifying the difference between creases and valleys.
    This filter works similar to the inverted direction of the
    [Smooth](../brushes/smooth.html) brush.

Erase Multires Displacement
:   Deletes displacement information of
    the [Multires Modifier](../../../modeling/modifiers/generate/multiresolution.html),
    resetting the mesh to a regular subdivision surface result.
    This can be used to reset parts of the sculpt or to fix reprojection artifacts
    after applying a [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.html).

    Negative strokes will intensify the displacement details,
    this method works similar to *Enhance Details* and can give better results in some circumstances.

Randomize
:   Randomly moves vertices along the vertex normal.
    This filter works similar to the [Randomize Transform](../../../scene_layout/object/editing/transform/randomize.html#bpy-ops-object-randomize-transform).
user: Explain NodeTreeInterfaceSocketFloatDistance(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketFloatDistance(NodeTreeInterfaceSocket)

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

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

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Many blend-files reference external images or other linked blend-files.
A path tells Blender where to look for these files.
If the external files are moved, the blend-file that references them will not look right.

When you specify one of these external files, the default option is to make the path relative.
Blender stores a partial path evaluated relative to the directory location of the referencing blend-file.
This choice helps when you need to reorganize folders or move your files.

With a relative path, you can move the blend-file to a new location provided
the externally linked files are moved along with it.
For example, you could send someone a folder that contains a blend-file
and a subfolder of external images that it references.

When relative paths are supported, the File Browser provides a *Relative Path* checkbox,
when entering the path into a text field, use a double slash prefix (`//`) to make it so.

Relative paths are the default but this can be changed
in the [File](../../editors/preferences/file_paths.xhtml) tab of the *Preferences*.
user: Describe Filters from the Blender manual or Python API, including usage steps and snippets.

assistant: # Filters

Filters are tools which provide an alternative way of sculpting, because they do not rely on a brush radius.
Instead they will affect any vertices that are visible and not masked.

[image reference removed]

The strength is controlled by click & dragging from left to right.
The position of the cursor can be used to only affect specific areas, if auto-masking is used.

Many of the same brush types are also available as a filter type.
This way much of the mesh can simultaneously be smoothed, colored or have some cloth simulation applied.
user: Describe Built-in Color Spaces from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender’s OCIO configuration file is equipped by default to read/write files in these color spaces

### Display

Color spaces for displays and image files.

sRGB:
:   Standard RGB display space using Rec. 709 chromaticities and a D65 white point.

Rec.2020:
:   BT.2020 2.4 Exponent EOTF Display.

Rec.1886:
:   BT.1886 2.4 Exponent EOTF Display, commonly used for TVs.

Display P3:
:   Apple’s Display P3 with sRGB compound (piece-wise) encoding transfer function, common on Mac devices.

Rec.2100 PQ:
:   For high dynamic range images and video with Rec.2020 wide gamut, up to 10000 nits.

Rec.2100 HLG:
:   For high dynamic range images and video with Rec.2020 wide gamut, up to 1000 nits.

### Linear

Color spaces commonly used for OpenEXR files.

Working Space:
:   The linear working space of the current blend file,
    that is used by default in compositing, shader and geometry nodes.

Linear Rec.709:
:   Linear BT.709 chromaticities with illuminant D65 white point.

Linear Rec.2020:
:   Linear BT.2020 with illuminant D65 white point.

ACEScg:
:   An ACES color space that is designed to be used for rendering and compositing.
    It uses the AP1 color primaries, a D60 white point, and a linear transfer function.
    The standard working space in ACES workflows.

ACES2065-1:
:   An ACES color space using the AP0 color primaries, a D60 white point and a linear transfer function.
    This color space is meant to store and transfer data, preserving the most information possible.
    Commonly used for delivery and archival in ACES workflows.

Linear FilmLight E-Gamut:
:   Linear E-Gamut with illuminant D65 white point.

Linear DCI-P3 D65:
:   Linear DCI-P3 with illuminant D65 white point.

Linear CIE-XYZ E:
:   1931 CIE XYZ standard with assumed illuminant E white point.

Linear CIE-XYZ D65:
:   1931 CIE XYZ with adapted illuminant D65 white point.

### Other

Non-Color:
:   Generic data that is not color, will not apply any color transform (e.g. normal maps or displacement maps).

Working Space:
:   Uses the [File](#bpy-types-blendfilecolorspace-working-space)
    color space defined in the scene’s color management settings.

### Log

ACEScc:
:   ACES color correction space, using AP1 primaries.

ACEScct:
:   ACES color correction space with toe, using AP1 primaries.

AgX Log:
:   Intermediate log color space of AgX view transform.

Filmic Log:
:   Intermediate log color space of Filmic view transform.

### Utilities

Color spaces corresponding to view transforms. These color spaces can
be used for background images that should not be affected by the view
transform, while everything else in the scene is affected.

ACES 1.3 sRGB:
:   ACES 1.3 view transform

ACES 2.0 sRGB:
:   ACES 2.0 view transform

AgX Base sRGB:
:   AgX view transform

Filmic sRGB:
:   Filmic view transform

Khronos PBR Neutral sRGB:
:   Khronos PBR Neutral view transform
user: How do I use Key Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: Most items in this menu are documented on the Graph Editor’s [Editing F-Curves](../graph_editor/fcurves/editing.xhtml) page.
One important difference is that scaling keyframes in the Dope Sheet Editor only moves them along the time axis
(with the Playhead serving as the pivot point); it doesn’t change their values.

The Dope Sheet editor has the following additional menu items:

Slide `Shift`-`T`
:   Lets you stretch one set of keyframes across time while compressing an adjacent set to compensate,
    leaving the combined duration the same.

    To use this operator, first select a range of three or more keyframes, then place the mouse cursor
    somewhere in the middle and press `Shift`-`T`. The range will be temporarily split in two
    at the location of the cursor, indicated by a dashed vertical line.
    If you now move the mouse, the two halves of the range will change in length,
    and the keyframes within them will move accordingly. Click `LMB` to confirm or `RMB` to cancel.

Keyframe Type `R`
:   Sets the [type](../../animation/keyframes/introduction.xhtml#keyframe-type) of the selected keyframes.
user: Explain Duplicate in complete detail according to the official Blender documentation.

assistant: Duplicate a strip to make an unlinked copy;
drag it to a time and channel, and drop it by `LMB` click.

For strips that reference an ID, for example scene strips, this will
duplicate the scene and use this new scene in the duplicated strip.
user: Show practical ways to work with CompositorNodeCustomGroup(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeCustomGroup(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.CompositorNodeCustomGroup(*CompositorNode*)
:   Custom Compositor Group Node for Python nodes

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

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

assistant: ### Nearest Surface Point

This will select the nearest point over the surface of the shrunk target.

### Project

[[image reference removed]](../../../_images/modeling_modifiers_deform_shrinkwrap_project.png)

Project mode.

This will project vertices along a chosen axis until they touch the shrink target.
Vertices that never touch the shrink target are left in their original position.

Limit
:   This is a distance limit between original vertex and surface.
    If the distance is larger than this limit vertex would not be projected onto the surface.

Subdivision Levels
:   This applies a (temporary) *Catmull-Clark* subdivision to the modified object’s geometry,
    before computing the wrap.

Axis
:   Along which local axis of the modified object the projection is done.
    These options can be combined with each other, yielding a “median axis” of projection.
    If none are selected, the normal direction is used.

Negative/Positive
:   This allows you to select the allowed direction(s) of the shrink along the selected axis.
    If both options are enabled, both ways are evaluated and the closest hit is selected.

Face Cull
:   Allows you to prevent any projection over the “front side”
    (respectively the “back side”) of the target’s faces. The “side” of a face is determined
    by its normal (front being the side “from where” the normal “originates”).

Invert Cull
:   If *Cull Faces* is enabled, and *Negative* direction along axis is allowed,
    this option can be used to invert the *Front* or *Back* cull choice
    for the *Negative* direction. This is useful when projecting in both directions.

Auxiliary Target
:   An additional object to project over.

### Nearest Vertex

[[image reference removed]](../../../_images/modeling_modifiers_deform_shrinkwrap_nearest-vertex.png)

Nearest Vertex mode.

This will snap vertices to the nearest vertex of the shrunk target. It adds no extra options.

This method doesn’t support the *Snap Mode* setting.

### Target Normal Project

[[image reference removed]](../../../_images/modeling_modifiers_deform_shrinkwrap_normal-project.png)

Target Normal Project mode.

This mode is similar to *Nearest Surface Point*, but produces a much smoother
projection in return for being significantly slower.

Instead of finding the closest point, it searches for the nearest point
that has its interpolated smooth normal pointing towards or away from the original vertex position.
Non-manifold boundary edges are specially handled as infinitely thin cylinders
that emit normals in all perpendicular directions; ignores flat shading.
user: Describe Shade Flat from the Blender manual or Python API, including usage steps and snippets.

assistant: Signify the object to render and display faces uniformly,
using the [Face Normal’s](../../../modeling/meshes/structure.html#modeling-meshes-structure-normals) direction.
This is usually desirable for objects with flat surfaces.

This operator will also remove any [Smooth By Angle Modifiers](../../../modeling/modifiers/normals/smooth_by_angle.html)

Keep Sharp Edges
:   Do not clear sharp edges (which are redundant with objects shaded as flat).
    This option is useful to not destroy data in case you want to revert changes later.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Component
:   The material component to base the toon effect.

    Diffuse:
    :   Use shading based on the Diffuse BSDF.

    Glossy:
    :   Use shading based on the Glossy BSDF for specular reflection.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeBake.bake_items`](bpy.types.GeometryNodeBake.html#bpy.types.GeometryNodeBake.bake_items "bpy.types.GeometryNodeBake.bake_items") - [`NodeGeometryBakeItems.new`](bpy.types.NodeGeometryBakeItems.html#bpy.types.NodeGeometryBakeItems.new "bpy.types.NodeGeometryBakeItems.new") | - [`NodeGeometryBakeItems.remove`](bpy.types.NodeGeometryBakeItems.html#bpy.types.NodeGeometryBakeItems.remove "bpy.types.NodeGeometryBakeItems.remove") |
user: How do I use KeyingSetsAll(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # KeyingSetsAll(bpy_struct)

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

*class* bpy.types.KeyingSetsAll(*bpy_struct*)
:   All available keying sets

    active
    :   Active Keying Set used to insert/delete keyframes

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

    active_index
    :   Current Keying Set index (negative for ‘builtin’ and positive for ‘absolute’)

        Type:
        :   int in [-inf, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Mode
:   Whether to update left or right or both handles.
    When both are selected, both the left and the right handles will be updated.

    Left:
    :   Update the left handles.

    Right:
    :   Update the right handles.

Handle Type
:   The handle type to switch to. See the [Bézier curves](../../../curves/structure.xhtml#curve-bezier-handle-type)
    page for more details on the different handle types.
user: How do I use Bpy.Types.Nodetreeinterfacesocketvectordirection2D in Blender? Include parameters, examples, warnings and best practices.

assistant: py() Inherited Properties Inherited Functions
user: Show practical ways to work with Toolbar in a Blender add-on or script – include code.

assistant: # Toolbar

Metaball Edit Mode tools:

[Tweak](../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or move.

    [Select Box](../../../interface/selecting.xhtml#tool-select-box)
    :   Select objects by dragging a box.
        All objects that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.xhtml#tool-select-circle)
    :   Select objects by dragging a circle. All objects that intersect the path of
        the circle will be selected.

    [Select Lasso](../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select objects by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

Shear
:   Shear selected items along a defined axis.
user: Provide the full official documentation entry for Connect, preserving all code examples.

assistant: The quickest way to constrain two objects is to select both and
click the *Connect* button in Object ‣ Rigid Body.
This creates a new empty object (named “Constraint”) with a physics constraint
already attached and pointing at the two selected objects.
user: Provide the full official documentation entry for OperatorMousePath(PropertyGroup), preserving all code examples.

assistant: # OperatorMousePath(PropertyGroup)

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

*class* bpy.types.OperatorMousePath(*PropertyGroup*)
:   Mouse path values for operators that record such paths

    loc
    :   Mouse location

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

    time
    :   Time of mouse location

        Type:
        :   float in [-inf, inf], 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: How do I use Smoothing of Cloth in Blender? Include parameters, examples, warnings and best practices.

assistant: Now, if you followed this from the previous section, your cloth is probably looking a little blocky.
In order to make it look nice and smooth like the picture you need to apply
a Smooth and/or Subdivision Surface Modifier in the *Modifiers* tab.
Then, in the Toolbar, find the *Edit* panel and Press *Smooth*.
user: How do I use CompositorNodeImageInfo(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeImageInfo(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.CompositorNodeImageInfo(*CompositorNode*)
:   Returns information about an image

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

assistant: # FCurveSample(bpy_struct)

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

*class* bpy.types.FCurveSample(*bpy_struct*)
:   Sample point for F-Curve

    co
    :   Point coordinates

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

    select
    :   Selection status

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Hue/Saturation Modifier.

Mode
:   The color transformation will be applied on the stroke and/or the fill color.

    Stroke & Fill, Stroke, Fill

Hue
:   Specifies the hue rotation of the image. 360° are mapped to (0 to 1).
    The hue shifts of 0 (-180°) and 1 (+180°) have the same result.

Saturation
:   A saturation of 0 removes hues from the image, resulting in a grayscale image.
    A shift greater than 1.0 increases saturation.

Value
:   Value is the overall brightness of the image.
    De/Increasing values shift an image darker/lighter.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).