PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of ActionLayers(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ActionLayers(bpy_struct)

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

*class* bpy.types.ActionLayers(*bpy_struct*)
:   Collection of animation layers

    new(*name*)
    :   Add a layer to the Animation. Currently an Animation can only have at most one layer.

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – Name, Name of the layer, will be made unique within the Action

        Returns:
        :   Newly created animation layer

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

    remove(*anim_layer*)
    :   Remove the layer from the animation

        Parameters:
        :   **anim_layer** ([`ActionLayer`](bpy.types.ActionLayer.html#bpy.types.ActionLayer "bpy.types.ActionLayer")) – Animation Layer, The layer 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 Inputs: syntax, arguments, return values, common patterns.

assistant: Color 1/2
:   Color of the bricks.

Mortar
:   The color of the area between bricks.

Scale
:   Overall texture scale.

Mortar Size
:   The size of the filling between the bricks known as “mortar”; 0 means no mortar.

Mortar Smooth
:   Blurs/softens the edge between the mortar and the bricks.
    This can be useful with a texture and displacement textures.

Bias
:   The color variation between *Color 1/2*.
    Values of -1 and 1 only use one of the two colors; values in between mix the colors.

Brick Width
:   The width of the bricks.

Row Height
:   The height of the brick rows.
user: Describe Independent Sites from the Blender manual or Python API, including usage steps and snippets.

assistant: There are [several independent websites](https://www.blender.org/community/) such as forums, blogs, news, and
tutorial sites dedicated to Blender.

One of the largest community forums is [Blender Artists](https://blenderartists.org/), where Blender users gather
to show off their creations, get feedback, ask and offer help and, in general, discuss Blender.
user: What is Toggle Cyclic and how is it used in Blender Python scripting?

assistant: Toggles between an open curve and closed curve (Cyclic).
Only curves with at least one selected control point will be closed/open.
The shape of the closing segment is based on the start and end handles for Bézier curves,
and as usual on adjacent control points for NURBS.
The only time a handle is adjusted after closing is if the handle is an *Auto* one.
Fig. [Open and Closed curves.](#fig-curve-editing-open-close) is the same Bézier curve open and closed.

This action only works on the original starting control point or the last control point added.
Deleting a segment(s) does not change how the action applies;
it still operates only on the starting and last control points. This means that
`Alt`-`C` may actually join two curves instead of closing a single curve!
Remember that when a 2D curve is closed, it creates a renderable flat face.

[image reference removed]

Open and Closed curves.
user: Provide the full official documentation entry for Modifiers, preserving all code examples.

assistant: ### Common Options

Mix
:   The modifier output can be mixed with the base property using the usual methods
    (see for example the [Mix compositing node](../../../../compositing/types/color/mix_color.html)).

Influence
:   How much the result of this modifier affects the current property.

Mapping
:   Either a linear progression (from 0.0 to 1.0),
    or a custom mapping [curve](../../../../interface/controls/templates/curve.html#ui-curve-widget).

Invert
:   Inverts the *Mapping*.

### Types

- [Along Stroke](modifiers/alpha/along_stroke.html)
- [Crease Angle](modifiers/alpha/crease_angle.html)
- [Curvature 3D](modifiers/alpha/curvature_3d.html)
- [Distance from Camera](modifiers/alpha/distance_from_camera.html)
- [Distance from Object](modifiers/alpha/distance_from_object.html)
- [Material](modifiers/alpha/material.html)
- [Noise](modifiers/alpha/noise.html)
- [Tangent](modifiers/alpha/tangent.html)
user: Show practical ways to work with NDOF in a Blender add-on or script – include code.

assistant: These preferences control how an [NDOF device](../../getting_started/configuration/hardware.xhtml#hardware-ndof) (3D mouse) interacts with the 3D Viewport.
These settings allow customization of navigation, orbit behavior, and motion sensitivity.
They can also be accessed using the `NDOFMenu` button on supported devices,
which opens a pop-up menu to adjust them directly in the viewport.

Navigation Mode
:   Sets how the 3D mouse navigates in the 3D Viewport.

    Object:
    :   Feels like holding the object in your hand. Moving the 3D mouse moves the object in that direction.

    Fly/Helicopter:
    :   Moves the camera through the scene, like flying or piloting a helicopter.
        For example, pushing the 3D mouse up moves the camera up.

Lock Horizon
:   Keeps the view level by preventing horizon tilt during navigation.

Orbit Center – Auto
:   Automatically determines the rotation center. If the full model is visible,
    its center of volume is used. When zoomed in, the rotation center shifts to the nearest visible object.

Orbit Center – Selected Items
:   Limits the orbit center to the center of the currently selected objects.

Show – Orbit Axis
:   Displays an axis overlay to indicate the current orbit rotation direction.

Show – Orbit Center
:   Displays a marker showing the current orbit center point.

### Advanced

Pan Sensitivity
:   Controls how quickly the view pans in response to NDOF input.

Orbit Sensitivity
:   Controls how quickly the view orbits in response to NDOF input.

Deadzone
:   Sets the minimum threshold for motion detection. Helps avoid unintended movement from slight touches.

Zoom Direction
:   Determines which direction on the 3D mouse triggers zooming.

    Forward/Backward:
    :   Zooms in or out by pushing or pulling the 3D mouse forward/backward.

    Up/Down:
    :   Zooms in or out by pushing or pulling the 3D mouse upward/downward.

Invert Pan
:   Inverts panning on the selected X, Y, or Z axis.

Invert Rotate
:   Inverts rotation direction on the selected X, Y, or Z axis.

Pan / Zoom Camera View
:   When in camera view, pans or zooms the camera instead of exiting the view during orbiting.
user: Provide the full official documentation entry for Rotation Modes, preserving all code examples.

assistant: # Rotation Modes

Blender lets you define rotations in several ways. Each one of them has a series of advantages and drawbacks;
there is no best rotation mode, as each one is suitable for specific cases.

In all of these modes, positive angle values mean counter-clockwise rotation direction,
while negative values define clockwise rotation.

Though you can rotate elements using the global or local transform orientations,
these axes are not suitable to define rotations, as the effect of each of
them cannot be isolated from the other two.

Take, for instance, any three values for X, Y and Z rotation. Perform each one of these using global or local axes.
Depending on the order in which you perform these, you will end up with different final orientations.
So proper rotation coordinate systems are needed.
user: How do I use Set Material Index Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Material Index Node

[image reference removed]

The *Set Material Index* node sets the material index for a geometry.

The node to get this data is the [Material Index](material_index.html) node.
user: What is Separate Spherical Node and how is it used in Blender Python scripting?

assistant: # Separate Spherical Node

[image reference removed]

The *Separate Spherical* node converts a vector from Cartesian coordinates (X, Y, Z)
into spherical coordinates (R, Φ, Θ) and outputs each component separately.
It is the inverse of the [Combine Spherical](../../../../modeling/geometry_nodes/utilities/vector/combine_spherical.xhtml) node.

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: Explain Rendering Technologies in complete detail according to the official Blender documentation.

assistant: Blender supports different technologies to render on the GPU depending on the particular GPU manufacturer
and operating system.

### CUDA – NVIDIA

CUDA is supported on Windows and Linux and requires a
NVIDIA graphics cards with compute capability 5.0 and higher. To make sure your GPU is supported,
see the [list of NVIDIA graphics cards](https://developer.nvidia.com/cuda-gpus#compute)
with the compute capabilities and supported graphics cards.

### OptiX – NVIDIA

OptiX is supported on Windows and Linux and requires a NVIDIA graphics cards with compute capability 5.0 and higher
and a driver version of at least 535. To make sure your GPU is supported,
see the [list of NVIDIA graphics cards](https://developer.nvidia.com/cuda-gpus#compute).

OptiX takes advantage of hardware ray-tracing acceleration in RTX graphics cards, for improved performance.

GPU acceleration for OpenImageDenoise is available for compute capability 7.0 and higher, which includes
all NVIDIA RTX cards.

### HIP – AMD

HIP is supported on Windows and Linux and requires a
AMD graphics card with the RDNA1 architecture or newer. Both discrete GPUs and APUs are supported.

Supported GPUs include:

- Radeon RX 5000 Series
- Radeon RX 6000 Series
- Radeon RX 7000 Series
- Radeon RX 9000 series
- Radeon Pro W6000 Series
- Radeon Pro W7000 Series

Minimum driver versions:

- Windows: Radeon Software 24.9.1 or Radeon PRO Software 24.Q4
- Linux: Radeon Software 23.40 or ROCm 6.0

Please refer to [AMD’s website](https://www.amd.com/en/products/specifications.html) for more
information about AMD graphics cards and their architectures.

Hardware ray-tracing support is available with the most recent drivers.
This can be enabled in the preferences, and is supported on Radeon RX 6000 and newer.

GPU accelerated denoising is available on discrete Radeon RX 6000 and Radeon RX 7000 GPUs.

### oneAPI – Intel

oneAPI is a computation library that is supported on Windows and Linux and requires a
Intel® Arc™ graphics card with the Xe HPG architecture.
Hardware acceleration for ray-tracing and denoising is supported.

Supported GPUs include:

- Intel® Arc™ A-Series
- Intel® Arc™ B-Series

Minimum driver versions:

- Windows: Intel Graphics Driver XX.X.101.5518
- Linux: `intel-level-zero-gpu` package 1.3.27642,
  typically available through the `intel-compute-runtime` package XX.XX.34666.3

Please refer to [Intel’s website](https://www.intel.com/content/www/us/en/products/details/discrete-gpus.html)
for more information about Intel graphics cards and their architectures.

GPU accelerated denoising is available on all supported GPUs.

### Metal – Apple (macOS)

Metal is supported on Apple computers with Apple Silicon.
macOS 13.0 or newer is required to support all features.

GPU accelerated denoising is available on Apple Silicon.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Maintain Volume constraint.

Mode
:   Specifies how the constraint handles scaling of the non-free axes.

    Strict:
    :   Adjusts the scales of the non-free axes so that the volume is always exactly maintained.
        Scaling up the free axis will scale down both non-free axes. Scaling up a non-free axis
        will scale down the other non-free axis.

    Uniform:
    :   Unlike *Strict*, this mode only maintains the volume correctly as long as the object
        is scaled equally along all three axes.

        Scaling up the free axis alone will also scale down the non-free axes, but
        in an exaggerated manner that results in a loss of volume. As such, this is
        not recommended.

        Scaling up a non-free axis has no effect on the other non-free axis. This
        makes it possible to deviate from the target volume.

    Single Axis:
    :   Similar to *Uniform*, except the mode only maintains the volume correctly as long
        as the object is scaled purely along the free axis. Because only one axis needs to
        be adjusted to keep the volume instead of three, this may reduce the number of
        animation curves needed.

        Changing the scale of a non-free axis again has no effect on the other non-free axis.

Free Axis
:   The axis that should keep its user-specified scale. The other two (non-free) axes will
    be adjusted to maintain the volume.

Volume
:   The target volume as a ratio of the original volume (when all axes have a scale of 1).

    If all three axes have a default scale of 2 and this should be maintained, *Volume* should
    be set to 2×2×2 = 8.

[Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The space for determining and adjusting the scale of the owner.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Provide the full official documentation entry for Viewpoint, preserving all code examples.

assistant: # Viewpoint

The menu View ‣ Viewpoint lets you align the viewing direction to
a specific axis. This can also be done using the [Navigation Gizmo](introduction.xhtml#navigation-gizmo)
or the following hotkeys:

Top:
:   `Numpad7`

Front:
:   `Numpad1`

Right:
:   `Numpad3`

Bottom:
:   `Ctrl`-`Numpad7`

Back:
:   `Ctrl`-`Numpad1`

Left:
:   `Ctrl`-`Numpad3`

The above hotkeys align the view to a global (world) axis. You can also align to a local axis
of the selected item by additionally holding `Shift`. This way, you can for example
view any mesh face head-on, no matter how it’s oriented.
(To get out of this local viewpoint, simply align to a global axis again.)

The view can also be aligned by holding `Alt`-`MMB` and dragging the mouse in a certain direction.
user: Give a detailed overview of Alembic: syntax, arguments, return values, common patterns.

assistant: # Alembic

From the [Alembic home page](https://www.alembic.io/):

> Alembic is an open computer graphics interchange framework. Alembic distills complex, animated
> scenes into a non-procedural, application-independent set of baked geometric results.
> This ‘distillation’ of scenes into baked geometry is exactly analogous to the distillation of
> lighting and rendering scenes into rendered image data.
>
> Alembic is focused on efficiently storing the computed results of complex procedural geometric constructions.
> It is very specifically **not** concerned with storing the complex dependency graph
> of procedural tools used to create the computed results.
> For example, Alembic will efficiently store the animated vertex positions and
> animated transforms that result from an arbitrarily complex animation and simulation process
> which could involve enveloping, corrective shapes, volume-preserving simulations,
> cloth and flesh simulations, and so on.
> Alembic will not attempt to store a representation of the network of computations (rigs, basically)
> which are required to produce the final, animated vertex positions and animated transforms.

In brief, Alembic can be used to write an animated mesh to a drive, and read it back quickly and efficiently.
This means that a mesh can be animated with a very CPU-intensive rig and then ‘baked’ to an Alembic file.
Finally it can be load into the shot file for shading and lighting with only moderate CPU usage.

Due to the Open Source nature of the Alembic standard as well as
the C++ library implementing that standard, **Blender can be used in a hybrid pipeline**.
For example, other software, such as Houdini or Maya, can export files to Alembic,
which can then be loaded, shaded, and rendered in Blender.
It is also possible to animate characters (or other models) in Blender, export to Alembic, and
load those files into other software for further processing.
user: Explain FunctionNodeTransformDirection(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeTransformDirection(FunctionNode)

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

*class* bpy.types.FunctionNodeTransformDirection(*FunctionNode*)
:   Apply a transformation matrix (excluding translation) to the given vector

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

assistant: Device
:   The device used for compositing.

    CPU:
    :   Use the CPU for compositing.

    GPU:
    :   Use the GPU for compositing.

Precision GPU
:   The precision of compositor intermediate result.

    Auto:
    :   Use full precision for final renders, half precision otherwise.

    Full:
    :   Use full precision for final renders and viewport.

### Denoise Nodes

Denoising Device
:   The device to use to process [Denoise nodes](../../../compositing/types/filter/denoise.html) in the compositor.

    Auto:
    :   Use the same device used by the compositor to process the denoise node.

    CPU:
    :   Use the CPU to process the denoise node.

    GPU:
    :   Use the GPU to process the denoise node if available, otherwise fallback to CPU.

Preview Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.html) during viewport
    and interactive compositing of a render if their quality is set to *Follow Scene*.

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.

Final Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.html) during the final
    render if their quality is set to *Follow Scene*.

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: For instance X: 0.5 and Y: 0.5 would produce an image which width and
height would be half of what they used to be.

Use this node to match image sizes.
Most nodes produce an image that is the same size as the image input into their top image socket.
To uniformly combine two images of different size,
the second image has to be scaled up to match the resolution of the first.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Data Type
:   The [data type](../../attributes_reference.xhtml#attribute-data-types) used for the retrieved data.
    [Attribute Search](../../inspection.xhtml#geometry-nodes-attribute-search) can be used to give a basic list of possible
    attribute names and data types. When a value is chosen from the search menu, the data
    type is set to automatically choose the data type from the geometry nodes result.
user: Describe Convex Hull from the Blender manual or Python API, including usage steps and snippets.

assistant: # Convex Hull

The Convex Hull operator takes a point cloud as input and outputs a convex hull surrounding those vertices.
If the input contains edges or faces that lie on the convex hull, they can be used in the output as well.
This operator can be used as a bridge tool as well.

[image reference removed]

Input mesh, point cloud, and Convex Hull result.

Delete Unused
:   Removes vertices, edges, and faces that were selected, but not used as part of the hull.
    Note that vertices and edges that are used
    by other edges and faces not part of the selection will not be deleted.

Use Existing Faces
:   Where possible, use existing input faces that lie on the hull.
    This allows the convex hull output to contain n-gons rather than triangles
    (or quads if the *Join Triangles* option is enabled).

Make Holes
:   Delete edges and faces in the hull that were part of the input too.
    Useful in cases like bridging to delete faces between the existing mesh and the convex hull.

Join Triangles
:   Joins adjacent triangles into quads.
    Has all the same properties as the [Triangles to Quads](../face/triangles_quads.xhtml#bpy-ops-mesh-tris-convert-to-quads)
    operator (angle limit, compare UVs, etc.).

Max Face Angle, Max Shape Angle, Compare
:   See [Triangles to Quads](../face/triangles_quads.xhtml#bpy-ops-mesh-tris-convert-to-quads).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Color
:   Scattering coefficients per color channel.

Density
:   The density of the scatter effect.

Anisotropy Henyey-Greenstein Draine
:   Controls the relative amount of backward and forward scattering.

IOR Fournier-Forand
:   Refractive index of the scattering particles relative to water. Common ocean waters range between
    1.0 and 1.2, while turbid waters with higher density of particles have higher IORs.

Backscatter Fournier-Forand
:   Fraction of light that is scattered backwards. Most oceanic particles have backscatter
    values between 0.001 (e.g., very large phytoplankton) and 0.1 (e.g., very small mineral particles),
    pure water has a backscatter of 0.5. Values taken from
    [Ocean Optics Web Book](https://www.oceanopticsbook.info/view/scattering/the-fournier-forand-phase-function).

Alpha Draine
:   Blending factor between Henyey-Greenstein (\(\alpha = 0\))
    and Cornette & Shanks (\(\alpha = 1\)) phase functions.

Diameter Mie
:   Diameter of the scattering particles in µm.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Domain
:   The [attribute domain](../attributes_reference.xhtml#attribute-domains) used to evaluate the *Value* input.
    The *Auto* option chooses the domain automatically based on the connected nodes.

### Viewer Items

Socket Type
:   The data type used to evaluate the input.

Auto Remove
:   Remove the item automatically when it is unlinked.
user: How do I use Select Face Loops in Blender? Include parameters, examples, warnings and best practices.

assistant: In face select mode, holding `Alt` while selecting an *edge* selects a loop of
faces that are connected in a line end-to-end, along their opposite edges.

In vertex select mode,
the same can be accomplished by using `Ctrl`-`Alt` to select an edge,
which selects the face loop implicitly.

[image reference removed]

Face loop selection.

This face loop was selected by clicking with `Alt`-`LMB` on an edge,
in *face* select mode.
The loop extends perpendicular from the edge that was selected.

[image reference removed]

`Alt` versus `Ctrl`-`Alt` in vertex select mode.

A face loop can also be selected in *Vertex* select mode.
Technically `Ctrl`-`Alt`-`LMB` will select an *Edge Ring*,
however, in *Vertex* select mode, selecting an *Edge Ring* implicitly
selects a *Face Loop* since selecting opposite edges of a face implicitly selects
the entire face.
user: What is Curves Handle Type Items and how is it used in Blender Python scripting?

assistant: # Curves Handle Type Items

FREE:
:   Free.

    The handle can be moved anywhere, and does not influence the point’s other handle.

AUTO:
:   Auto.

    The location is automatically calculated to be smooth.

VECTOR:
:   Vector.

    The location is calculated to point to the next/previous control point.

ALIGN:
:   Align.

    The location is constrained to point in the opposite direction as the other handle.
user: What is ImagePackedFile(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ImagePackedFile(bpy_struct)

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

*class* bpy.types.ImagePackedFile(*bpy_struct*)
:   filepath
    :   Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

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

    tile_number
    :   Type:
        :   int in [-inf, inf], default 0, (readonly)

    view
    :   Type:
        :   int in [-inf, inf], default 0, (readonly)

    save()
    :   Save the packed file to its filepath

    *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 Duplicate Linked from the Blender manual or Python API, including usage steps and snippets.

assistant: # Duplicate Linked

You also have the choice of creating a *Linked Duplicate* rather than a *Duplicate*;
this is called a deep link. This will create a new object with **all** of its data linked to
the original object. If you modify one of the linked objects in *Edit Mode*,
all linked copies are modified. Transform properties (object data-blocks) still remain copies,
not links, so you still can rotate, scale, and move freely without affecting the other copies.
Reference the [Examples](#examples) for the discussions below.

If the original object was animated, the duplicate will link to the same [Action](../../../animation/actions.xhtml#bpy-types-action).
This means that, even though each object has separate transform properties,
they will be set to the same values by the animation system.
If this is not desired, make the action a single-user copy in the
[Action](../../../editors/dope_sheet/modes/action.xhtml) or
[NLA Editor](../../../editors/nla/introduction.xhtml).

Linked
:   In the *Duplicate Objects* [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel the *Linked* checkbox is checked
    unlike with *Duplicate*.
user: What is NodeSocketMatrix(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketMatrix(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.NodeSocketMatrix(*NodeSocketStandard*)
:   Matrix value socket of a node

    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
user: Explain Erase Multires Displacement in complete detail according to the official Blender documentation.

assistant: # Erase Multires Displacement

This brush deletes displacement information of
the [Multires Modifier](../../../modeling/modifiers/generate/multiresolution.xhtml),
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.xhtml).
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: Default Fade
:   Automatically calculates a linear fade over the length of the strip.

    Effect Fader
    :   Allows you to manually [keyframe](../../../../../animation/keyframes/index.html) a custom fade.
        This can be used with different [easings](../../../../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-easing)
        to fine-tune the fade in/out.
user: What is Advect Grid Node and how is it used in Blender Python scripting?

assistant: # Advect Grid Node

[image reference removed]

The *Advect Grid* node moves voxel values through a velocity field over time
using numerical integration. This operation is called *advection* and is
commonly used in fluid, smoke, and motion simulation systems to evolve
quantities such as density, temperature, or color according to a flow field.

The node supports multiple integration schemes that trade off between speed,
accuracy, and numerical stability. It can be used for both scalar and vector
grids, provided the voxel size is uniform across the domain.

Advection is conceptually equivalent to tracing each voxel backward through the
velocity field by a small time step, sampling the grid value from the previous
location, and assigning that value to the current voxel.
user: How do I use Working With Actions in Blender? Include parameters, examples, warnings and best practices.

assistant: When you first animate an object (or other data-block) in Blender, Blender tries
to automatically find an appropriate action for it, or if it can’t find an
appropriate action then it will create one. After an action has been assigned,
it also creates and assigns a new slot for the data-block.

Blender uses heuristics to try to find an appropriate action, based on the
idea that animation of closely related data-blocks should typically go in the
same action. For example, an object and its data are considered closely related,
so if a camera object is already animated and you insert keys for its
[focal length](../glossary/index.xhtml#term-Focal-Length) (which lives on the camera data, *not* the
camera object), the action that’s assigned to the object will be reused for the
camera data as well. These relationships go both ways, so the action will also
be reused when keying the camera object if the camera data is already animated.

Some examples of other data-blocks that are considered closely related for this
purpose are: materials and their embedded node trees, worlds and their embedded
node trees, and meshes and their shape key data.

### Manually Assigning Actions and Slots

In addition to letting Blender automatically choose an action and slot for a
data-block, you can also manually assign them. This can be used to assign
existing animation to a data-block by selecting both the action and slot. It can
also be used to specify an action for a data-block’s keys to go into, by
assigning the action but leaving the slot blank, in which case a new slot will
be created when the first key is set.

For each data-block in the properties editor there is an Animation panel with
action and slot selectors. You can use these to assign actions and slots to a
data-block.

[image reference removed]

The action and slot selector for Camera data in the
[Properties Editor](../editors/properties_editor.xhtml).

For the active object you can also assign its action and slot in the action
Editor’s header.

[image reference removed]

The action and slot selector for the active object (in this case a camera object) in the
[Action Editor](../editors/dope_sheet/modes/action.xhtml).

When you select an action to animate a data-block, for convenience Blender
attempts to automatically select an appropriate slot for you based on name and
associated type. If no appropriate slot is found then the slot selector will
remain empty, in which case you can manually select an existing slot, create a
new one, or just start keying and let Blender automatically create a new slot
for you. If Blender assigns a slot you didn’t want, you can select another slot
manually or simply clear the slot selection.

### NLA

Actions can also be assigned to NLA strips within a data-block’s NLA system.
Please see the documentation for the [NLA Editor](../editors/nla/introduction.xhtml)
for how to animate data-blocks via the NLA system.
user: Describe Smooth Laplacian Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Smooth Laplacian Modifier

The *Smooth Laplacian* modifier allows you to reduce noise on a mesh’s surface with minimal changes to its shape.

It can also exaggerate the shape using a negative *Factor*.

The *Smooth Laplacian* is useful for objects that have been reconstructed from
the real world and contain undesirable noise. It removes noise while still
preserving desirable geometry as well as the shape of the original model.

This modifier is based on a curvature flow *Laplace Beltrami* operator in a diffusion equation.
user: What is Examples and how is it used in Blender Python scripting?

assistant: Below are examples of blending modes, as well as some practical use cases.

[image reference removed]

Blending a colored pattern with a flat color (top row) and a circular mask (bottom row).

### Fixing overexposure

The Compositing setup below shows how to fix an overexposed render by
darkening it and increasing contrast.

[image reference removed]

Example node setup showing two RGB Curves nodes and a Mix node for composition.

The top [RGB Curves Node](../../../../compositing/types/color/adjust/rgb_curves.xhtml) darkens the image by linearly scaling each
color value to a smaller one.

The bottom curve node increases contrast by making small values smaller and large values larger.

Finally, the Mix node blends the two together.

### Watermark Images

In the old days, a pattern was pressed into the paper mush as it dried,
creating a mark that identified who made the paper and where it came from.
The mark was barely perceptible except in just the right light.
Probably the first form of subliminal advertising.

Nowadays, people watermark their images to identify them as personal intellectual property,
for subliminal advertising of the author or hosting service,
or simply to track their image’s proliferation throughout the web.

Blender provides a complete set of tools for you to both encode your watermark
and to tell if an image has your watermark.

#### Encoding your Watermark in an Image

First, construct your own personal watermark.
You can use your name, a word, or a shape or image not easily replicated.
While neutral gray works best using the encoding method suggested,
you are free to use other colors or patterns.
It can be a single pixel or a whole gradient; it is up to you.

In the example below, we are encoding the watermark in a specific location
in the image using the *Translate* node;
this helps later because we only have to look at a specific location for the mark.
We then use the *RGB to BW node* to convert the color image to grayscale numbers,
which we then feed into the *Map Range* node to reduce the mark to one-tenth of
its original intensity.

The *Add* node (*Mix* node with blending mode *Add*) adds the corresponding pixels,
making the ones containing the mark ever-so-slightly brighter.

[image reference removed]

Embedding a watermark in an image.

Of course, if you *want* people to notice your mark, do not scale it so much,
or make it a contrasting color. There are also many other ways,
using other mix settings and fancier rigs. Feel free to experiment!

#### Decoding an Image for your Watermark

When you see an image that you think might be yours,
use the node tree below to compare it to your stock image (non-watermarked original).
In this tree, the *Mix* node is set to Difference,
and the *Map Value* node amplifies any difference.
You can see how the original mark clearly stands out.

[image reference removed]

Checking an image for your watermark.
user: What is Advanced and how is it used in Blender Python scripting?

assistant: ### The Offset/Power/Slope Formula

\(\text{out} = (i \times s + o)^p\)

where:

- *out*: The color graded pixel code value.
- *i*: The input pixel code value (0 to 1) (black to white).
- *s*: Slope (any number 0 or greater, nominal value is 1.0).
- *o*: Offset (any number, the nominal value is 0).
- *p*: Power (any number greater than 0, nominal value is 1.0).
user: Describe BlendDataProbes(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BlendDataProbes(bpy_struct)

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

*class* bpy.types.BlendDataProbes(*bpy_struct*)
:   Collection of light probes

    new(*name*, *type*)
    :   Add a new light probe to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **type** (enum in [Lightprobes Type Items](bpy_types_enum_items/lightprobes_type_items.html#rna-enum-lightprobes-type-items)) – Type, The type of light probe to add

        Returns:
        :   New light probe data-block

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

    remove(*lightprobe*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a light probe from the current blendfile

        Parameters:
        :   - **lightprobe** ([`LightProbe`](bpy.types.LightProbe.html#bpy.types.LightProbe "bpy.types.LightProbe"), (never None)) – Light probe to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this light probe before deleting it (WARNING: will also delete objects instancing that light probe data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this light probe
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this light probe

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

    *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 Fly Navigation and how is it used in Blender Python scripting?

assistant: On activation, the cursor is centered inside a rectangle that defines a safe zone.
When the cursor is outside this zone, the view will rotate/pan.

### Usage

Move the mouse outside the safe zone in the direction you want to look.

Click `LMB` or press `Spacebar` to keep the current view and exit Fly navigation.
In case you want to go back to where you started, press `Esc` or `RMB`.

|  |  |
| --- | --- |
| `W`/`Up` | Accelerate forward. |
| `S`/`Down` | Accelerate backward. |
| `A`/`Left` | Accelerate left. |
| `D`/`Right` | Accelerate right. |
| `E` | Accelerate upward. |
| `Q` | Accelerate downward. |
| `MMB` | Drag to pan the view. Flying will pause while you’re doing this. |
| `WheelUp`/`NumpadPlus` | Increase the acceleration in the direction of motion. If there is no motion, start accelerating forward. |
| `WheelDown`/`NumpadMinus` | Decrease the acceleration in the direction of motion. If there is no motion, start accelerating backward. |
| `Alt` | Slow down as long as the key is held, until the view eventually comes to a standstill. |
| `Ctrl` | Disable rotation – while held, the view rotation doesn’t influence the flight direction. This allows you to fly past an object, keeping it centered in the view even as you fly away from it. |
| `X` | Toggle X axis correction. If enabled, the view will smoothly pitch to look at the horizon when the cursor is in the safe zone. |
| `Z` | Toggle Z axis correction. If enabled, the view will smoothly roll to an upright orientation. |
user: What is Adding/Removing/Moving Files and how is it used in Blender Python scripting?

assistant: When RST-files are added or removed the corresponding locale files are added or removed automatically by the update
script. However, if files need to be moved please use this Python script:

```
python tools/utils_maintenance/rst_remap.py start
```

RST-files can then be freely moved and the remap script will move the locale file after:

```
python tools/utils_maintenance/rst_remap.py finish
```

It is best to avoid moving/renaming files as this breaks URLs and without this script translators will lose all their
work in these files. Please ask an administrator if you think something should be renamed/moved.
user: Give a detailed overview of Insert Blank Keyframe (Active Layer): syntax, arguments, return values, common patterns.

assistant: Add a new blank keyframe to the active layer at the current frame.
If there is already a keyframe at the current frame,
a new blank keyframe will be added on the next frame.

All Layers
:   When enabled, Blank keyframe will be created on all layers, not only the active one.

Duration
:   The number of blank frames to insert.
user: Provide the full official documentation entry for GeometryNodeSetInstanceTransform(GeometryNode), preserving all code examples.

assistant: # GeometryNodeSetInstanceTransform(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.GeometryNodeSetInstanceTransform(*GeometryNode*)
:   Set the transformation matrix of every instance

    *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 GeometryNodeInstanceTransform(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInstanceTransform(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.GeometryNodeInstanceTransform(*GeometryNode*)
:   Retrieve the full transformation of each instance in the geometry

    *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