PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is CompositorNodeRotate(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeRotate(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.CompositorNodeRotate(*CompositorNode*)
:   Rotate image by specified angle

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

assistant: # Smear Multires Displacement

This tool deforms displacement information of
the [Multires Modifier](../../../modeling/modifiers/generate/multiresolution.html),
moving the displaced vertices without affecting the base mesh.

Smearing effect can be used multiple times
over the same area without generating any artifacts in the topology.
user: Give a detailed overview of CollisionModifier(Modifier): syntax, arguments, return values, common patterns.

assistant: # CollisionModifier(Modifier)

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

*class* bpy.types.CollisionModifier(*Modifier*)
:   Collision modifier defining modifier stack position used for collision

    settings
    :   Type:
        :   [`CollisionSettings`](bpy.types.CollisionSettings.html#bpy.types.CollisionSettings "bpy.types.CollisionSettings"), (readonly, never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain MeshPolygons(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # MeshPolygons(bpy_struct)

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

*class* bpy.types.MeshPolygons(*bpy_struct*)
:   Collection of mesh polygons

    active
    :   The active face for this mesh

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

    add(*count*)
    :   add

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is FunctionNodeInvertRotation(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeInvertRotation(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.FunctionNodeInvertRotation(*FunctionNode*)
:   Compute the inverse of the given rotation

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Blur node blur modes using 20% of image size as XY, no Bokeh/Gamma.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/compositing_types_filter_blur-node_example-1-original.png   Original image. | ../../../../_images/compositing_types_filter_blur-node_example-2-flat.png   Flat. | ../../../../_images/compositing_types_filter_blur-node_example-3-tent.png   Tent. |
| ../../../../_images/compositing_types_filter_blur-node_example-4-quadratic.png   Quadratic. | ../../../../_images/compositing_types_filter_blur-node_example-5-cubic.png   Cubic. | ../../../../_images/compositing_types_filter_blur-node_example-6-gaussian.png   Gaussian. |
| ../../../../_images/compositing_types_filter_blur-node_example-7-fast-gaussian.png   Fast Gaussian. | ../../../../_images/compositing_types_filter_blur-node_example-8-catmull-rom.png   Catmull-Rom. | ../../../../_images/compositing_types_filter_blur-node_example-9-mitch.png   Mitch. |
user: How do I use Mark Seam in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Seamed Suzanne.

To add an edge to a seam, simply select the edge and press `Ctrl`-`E` to *Mark Seam*,
or to remove it, use `Ctrl`-`E` to *Clear Seam*.

In the example to the right, the back-most edge of the cylinder was selected as the seam
(to hide the seam), and the default unwrap calculation was used.
In the UV Editor, you can see that all the faces are nicely unwrapped,
just as if you cut the seam with a scissors and spread out the fabric.

When marking seams, you can use [Select Linked](../../selecting/linked.xhtml#bpy-ops-mesh-select-linked)
in Face Select Mode to check your work.
This menu option selects all faces connected to the selected one, up to a seam.
If faces outside your intended seam are selected, you know that your seam is not continuous.
You do not need continuous seams, however, as long as they resolve regions that may stretch.

Just as there are many ways to skin a cat, there are many ways to go about deciding where seams should go.
In general though, you should think as if you were holding the object in one hand, and a pair of
sharp scissors in the other, and you want to cut it apart and spread it on the table with as little
tearing as possible. Note that we seamed the outside edges of her ears, to separate the front from the back.
Her eyes are disconnected sub-meshes, so they are automatically unwrapped by themselves.
A seam runs along the back of her head vertically, so that each side of her head is flattened out.

Another use for seams is to limit the faces unwrapped. For example, when texturing a head, you
do not really need to texture the scalp on the top and back of the head since it will be
covered in hair. So define a seam at the hairline. Then, when you select a frontal face,
and then select linked faces before unwrapping,
the select will only go up to the hairline seam, and the scalp will not be unwrapped.

When unwrapping anything that is bilateral, like a head or a body, seam it along the mirror axis.
For example, cleave a head or a whole body right down the middle in front view. When you unwrap,
you will be able to overlay both halves onto the same [Texture Space](../../../../glossary/index.xhtml#term-Texture-Space),
so that the image pixels for the right hand will be shared with the left;
the right side of the face will match the left, etc.

### Seams from Islands

Adds seams at the boundaries of existing UV islands.
This is useful when modifying the UVs of already unwrapped meshes.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: From, To
:   The color space of the input image and the color space to convert it to.

    The list of color spaces depends on the active [OCIO config](../../../render/color_management/opencolorio.xhtml#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../../render/color_management/color_spaces.xhtml#ocio-config-default-color-spaces)
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Generated
:   Automatically-generated texture coordinates from the vertex positions of the mesh without deformation,
    keeping them sticking to the surface under animation.
    Range from 0.0 to 1.0 over the bounding box of the non-deformed mesh.
    See [Texture Spaces](../../../modeling/meshes/uv/uv_texture_spaces.html#properties-texture-space) for more information.

Normal
:   Object space normal, for texturing objects with the texture staying fixed on the object as it transformed.
    The Normal output can be used on Point and Spot lights. The coordinates will take
    the rotation of the light into account.

UV
:   UV texture coordinates from the [Active Render](../../../modeling/meshes/uv/uv_texture_spaces.html#bpy-types-meshuvlooplayer-active-render) UV map.
    See [UV Mapping](../../../editors/uv/index.html#editors-uv-index) for more information.

Object
:   Uses an object as a source for coordinates. Often used with an empty,
    this is an easy way to place a small image at a given point on the object.
    This object can also be animated, to move a texture around or through a surface.

Camera
:   Position coordinate in camera space.

Window
:   Location of shading point on the screen, ranging from 0.0 to 1.0
    from the left to right side and bottom to top of the render.
    This is well suited for blending two objects.

Reflection
:   Uses the direction of the reflection vector as coordinates.
    This is useful for adding reflection maps. You will need this input when using environment maps.
user: Give a detailed overview of Selection Node: syntax, arguments, return values, common patterns.

assistant: # Selection Node

[image reference removed]

The *Selection* node outputs true for geometry that is [selected](../../../../interface/selecting.xhtml), and false elsewhere.

The corresponding data flow node is the [Set Selection Node](../write/set_selection.xhtml).
user: Provide the full official documentation entry for Snap Target for Individual Elements, preserving all code examples.

assistant: Type of element for individual transformed elements to snap to.

Face Project:
:   Snaps to the face that’s under the mouse cursor.
    This can be used for bending a flat sheet so it snugly fits against a curved surface, for example.

    This works similar to the [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.xhtml).

Face Nearest:
:   Individually snaps each object (in Object Mode) or vertex (in Edit Mode) to the face that’s closest
    to its new location. This makes it possible to snap to occluded geometry.
user: What is Relations and how is it used in Blender Python scripting?

assistant: Parent
:   Select a Parent object to manipulate the layer.
    The layer will inherit the transformations of the parent,
    this is especially useful when rigging for cut-out animation.

Pass Index
:   The layer index number can be used with some modifiers to restrict changes to only certain areas.

    See [Modifiers](../modifiers/introduction.xhtml) for more information.

View Layer
:   Defines the View Layer to use for the Grease Pencil layer.
    If empty, the layer will be included in all View Layers.
    This is useful to separate drawings parts for [compositing](../../compositing/introduction.xhtml).

Use Masks in Render
:   If disabled, no masks on the layer are included in the view layer render.
user: How do I use Camera Info Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Camera Info Node

[image reference removed]

The *Camera Info* node outputs the information about the selected camera object.

It can be used to customize geometry based on the camera’s parameters,
for example when building camera-based visual effects or aligning geometry with the camera view.
user: Show practical ways to work with Flip Names in a Blender add-on or script – include code.

assistant: You can flip left/right markers (see above) in selected bone names.
This can be useful if you have constructed half of a symmetrical rig
(marked for a left or right side) and duplicated and mirrored it,
and want to update the names for the new side.
Blender will swap text in bone names according to the above naming conventions,
and remove number extensions if possible.
user: How do I use Select Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: All `A`
:   Selects all keyframes.

None `Alt`-`A`
:   Deselects all keyframes.

Invert `Ctrl`-`I`
:   Inverts the selection.

---

[Box Select](../../interface/selecting.xhtml#bpy-ops-select-box) `B`
:   Lets you drag a box and selects the keyframes inside it.

Box Select (Axis Range) `Alt`-`B`
:   Lets you drag a box and selects the keyframes inside the corresponding time range,
    even if they’re above or below the box.

[Circle Select](../../interface/selecting.xhtml#bpy-ops-select-circle) `C`
:   Displays a circle around the cursor, which you can drag over keyframes to select them.

[Lasso Select](../../interface/selecting.xhtml#bpy-ops-select-lasso) `Ctrl`-`RMB`
:   Lets you draw a freehand shape and selects the keyframes inside it.

---

More `Ctrl`-`NumpadPlus`
:   Expand the selection to include the neighbors (in time) of the currently selected keys.

Less `Ctrl`-`NumpadMinus`
:   Deselect keyframes with fewer than two selected neighbors.

---

Select Linked `L`
:   Select keys that are on the same channel as a key that’s already selected.

---

Columns on Selected Keys `K`
:   Selects keys that are on the same frame as a key that’s already selected.

Column on Current Frame `Ctrl`-`K`
:   Selects all the keys that are on the current frame.

Columns on Selected Markers `Shift`-`K`
:   Selects keys that are on the same frame as a selected marker.

Between Selected Markers `Alt`-`K`
:   Selects keys that lie between the leftmost and rightmost selected markers.

---

Before Current Frame `[`
:   Select the keys that lie before (or on) the current frame.
    You can also click `Shift`-`Ctrl`-`LMB` anywhere to the left of the Playhead.

After Current Frame `]`
:   Select the keys that lie after (or on) the current frame.
    You can also click `Shift`-`Ctrl`-`LMB` anywhere to the right of the Playhead.
user: How do I use Link Data in Blender? Include parameters, examples, warnings and best practices.

assistant: # Link Data

Performs various assignments: adding an object to a scene, giving an object the same
data or modifiers as another, and so on.

When you link two objects to the same data, changes made to one will also appear in the other.
Should you no longer want this, you can use [Making Single User](../../../../files/data_blocks.xhtml#data-system-datablock-make-single-user)
to once again give each object its own data.

Link Objects to Scene
:   Adds the selected objects to the specified scene. Objects can exist in multiple scenes
    at once and have the same position/animation in all of them.

---

Link Object Data
:   Replaces the [object data](../../introduction.xhtml) of the
    selected objects by that of the [active object](../../selecting.xhtml#object-active).

Link Materials
:   Replaces the [materials](../../../../render/materials/introduction.xhtml) of the selected
    objects by those of the active object.

Link Animation Data
:   Replaces the [actions](../../../../animation/actions.xhtml) and [tracks](../../../../editors/nla/tracks.xhtml)
    of the selected objects by those of the active object.

Link Collections
:   Moves the selected objects into the same
    [collections](../../../collections/introduction.xhtml) as the active object.

Link Instance Collection
:   Replaces the [instance collection](../../properties/instancing/collection.xhtml)
    of the selected objects by that of the active object.

Link Fonts to Text
:   Replaces the font of the selected [text objects](../../../../modeling/texts/introduction.xhtml) by that
    of the active text object.

---

Copy Modifiers
:   Replaces the [modifiers](../../../../modeling/modifiers/introduction.xhtml) of the selected objects
    by those of the active object.

Copy Grease Pencil Effects
:   Replaces the [visual effects](../../../../grease_pencil/visual_effects/introduction.xhtml) of the selected
    Grease Pencil objects by those of the active object.

Copy UV Maps
:   Replaces the active [UV map](../../../../editors/uv/introduction.xhtml) of each selected mesh object
    by the active UV map of the active object. If a selected object doesn’t have any UV maps,
    one is created.

    All objects must have matching geometry and face order. You can ensure the latter using
    [Sort Elements](../../../../modeling/meshes/editing/mesh/sort_elements.xhtml), but even then, this operator is really
    only useful if the destination is a deformed copy of the source. Use
    [Transfer Mesh Data](transfer_mesh_data.xhtml) for other cases.

---

Transfer Mesh Data
:   See [Transfer Mesh Data](transfer_mesh_data.xhtml).

Transfer Mesh Data Layout
:   See [Transfer Mesh Data Layout](transfer_mesh_data_layout.xhtml).

---

Link Receivers to Emitter
:   Adds the selected objects to the [Light Linking](../../../../render/lights/light_linking.xhtml)
    collection of the active light object.

Link Blockers to Emitter
:   Adds the selected objects to the [Shadow Linking](../../../../render/lights/light_linking.xhtml)
    collection of the active light object.
user: How do I use SDF Grid Mean Curvature Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # SDF Grid Mean Curvature Node

[image reference removed]

The *SDF Grid Mean Curvature* node applies mean curvature flow smoothing to a Signed Distance Field (SDF) grid.
This operation evolves the surface of the field over time based on its mean curvature,
causing high-curvature (sharp or noisy) regions to smooth out more rapidly than flatter areas.

Unlike simple averaging or Laplacian smoothing, mean curvature flow adapts to
the geometric features of the surface, providing a more natural, shape-preserving
smoothing process. It can be used to refine complex SDF surfaces, remove small
artifacts, and create organically blended transitions between features.

This node is particularly effective after boolean operations or mesh-to-SDF
conversion, where the resulting fields may contain high-frequency noise.
user: Give a detailed overview of Geometry Data: syntax, arguments, return values, common patterns.

assistant: # Geometry Data

This panel is used to manage any generic data attributes that a mesh could have.

Clear Sculpt Mask Data
:   Deletes the internal `sculpt_mask` attribute.
    This attribute is used by the [Sculpt Masking Feature](../../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.html#face-sets).

Add/Clear Skin Data
:   Used to manage the skin data which is used by the [Skin Modifier](../../modifiers/generate/skin.html).
    This operator can be needed in case a Skin modifier is created but no skin data exist.

Reorder Mesh Spatially
:   The operation sorts the vertex and face indices according to their location in space,
    so nearby geometry elements are also nearby in memory.

    This does not change the visible geometry or topology of the mesh.
    This does however improve performance in areas where spatial coherence is important, such as:

    - Faster BVH (Bounding Volume Hierarchy) building for rendering and viewport performance.
    - Improved memory access patterns during sculpting on high-poly meshes.
    - Potentially smoother interaction in edit and sculpt modes on dense geometry.

Add/Clear Custom Split Normals Data
:   Adds [Custom Split Normals](../structure.html#modeling-meshes-normals-custom) data, if none exists yet.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation to align.

Factor
:   Determines how much the points are rotated towards the vector.
    Zero effectively disables the node and one means that the points are aligned with the vector perfectly.

Vector
:   The direction vector that points should be rotated to.
    The vector is in the local space of the object that is being modified.
    When it is all zeros for a point, it is not rotated at all.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Vector
:   3D coordinate that’s projected onto the 2D image using the selected *Projection* method.
    The node then outputs the color and alpha at this projected point.

    This slot is usually connected to an output of the [Texture Coordinate Node](../input/texture_coordinate.xhtml).
    If left unconnected, the coordinate is taken from the object’s active UV map (with Z = 0).
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Selection of different types of media. For controls see [Data-Block Menu](../../../interface/controls/templates/data_block.html#ui-data-block).
    For the options see [Image Settings](../../../editors/image/image_settings.html).
user: Give a detailed overview of BrushTextureSlot(TextureSlot): syntax, arguments, return values, common patterns.

assistant: # BrushTextureSlot(TextureSlot)

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

*class* bpy.types.BrushTextureSlot(*TextureSlot*)
:   Texture slot for textures in a Brush data-block

    angle
    :   Brush texture rotation

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

    has_random_texture_angle
    :   Type:
        :   boolean, default False, (readonly)

    has_texture_angle
    :   Type:
        :   boolean, default False, (readonly)

    has_texture_angle_source
    :   Type:
        :   boolean, default False, (readonly)

    map_mode
    :   Type:
        :   enum in [`'VIEW_PLANE'`, `'AREA_PLANE'`, `'TILED'`, `'3D'`, `'RANDOM'`, `'STENCIL'`], default `'VIEW_PLANE'`

    mask_map_mode
    :   Type:
        :   enum in [`'VIEW_PLANE'`, `'TILED'`, `'RANDOM'`, `'STENCIL'`], default `'VIEW_PLANE'`

    random_angle
    :   Brush texture random angle

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

    use_rake
    :   Type:
        :   boolean, default False

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

assistant: The [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) shows the grids in the OpenVDB-file, listing their name and data type.
A “grid” is a set of volumetric data, which typically stores the density of each voxel
but can also contain temperatures, velocities and so on.

Click a grid to make the volume object display it.
user: Describe User Interface Layout from the Blender manual or Python API, including usage steps and snippets.

assistant: Some notes to keep in mind when writing UI layouts:

UI code is quite simple. Layout declarations are there to easily create a decent layout.
The general rule here is: If you need more code for the layout declaration,
than for the actual properties, then you are doing it wrong.

Example layouts:

`layout()`
:   The basic layout is a simple top-to-bottom layout.

    ```
    layout.prop()
    layout.prop()
    ```

`layout.row()`
:   Use `row()`, when you want more than one property in a single line.

    ```
    row = layout.row()
    row.prop()
    row.prop()
    ```

`layout.column()`
:   Use `column()`, when you want your properties in a column.

    ```
    col = layout.column()
    col.prop()
    col.prop()
    ```

`layout.split()`
:   This can be used to create more complex layouts.
    For example, you can split the layout and create two `column()` layouts next to each other.
    Do not use split, when you simply want two properties in a row. Use `row()` instead.

    ```
    split = layout.split()

    col = split.column()
    col.prop()
    col.prop()

    col = split.column()
    col.prop()
    col.prop()
    ```

Declaration names:

Try to only use these variable names for layout declarations:

row:
:   for a `row()` layout

col:
:   for a `column()` layout

split:
:   for a `split()` layout

flow:
:   for a `column_flow()` layout

sub:
:   for a sub layout (a column inside a column for example)
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Smooth Modifier.

Affect
:   Combination of stroke/points properties that will be affected by the smooth factor.

    Position:
    :   Smooth affect the point location.

    Strength:
    :   Smooth affect the point strength (opacity).

    Thickness:
    :   Smooth affect the point thickness.

    UV:
    :   Smooth affect the point UV rotation.

Factor
:   Strength of the smooth effect.

Repeat
:   The number of smoothing iterations, equivalent to executing the Smooth tool multiple times.
    High values can reduce the animation performance (FPS).

Keep Shape
:   When enabled, the smoothing algorithm will try to maintain as close as possible the overall
    shape of the original stroke.

Smooth Ends
:   Smooth the ends of the strokes.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Show practical ways to work with Dt Method Edge Items in a Blender add-on or script – include code.

assistant: # Dt Method Edge Items

TOPOLOGY:
:   Topology.

    Copy from identical topology meshes.

VERT_NEAREST:
:   Nearest Vertices.

    Copy from most similar edge (edge which vertices are the closest of destination edge’s ones).

NEAREST:
:   Nearest Edge.

    Copy from closest edge (using midpoints).

POLY_NEAREST:
:   Nearest Face Edge.

    Copy from closest edge of closest face (using midpoints).

EDGEINTERP_VNORPROJ:
:   Projected Edge Interpolated.

    Interpolate all source edges hit by the projection of destination one along its own normal (from vertices).
user: Explain Transform in complete detail according to the official Blender documentation.

assistant: Strokes can be edited by transforming the locations of points.

### Move, Rotate & Scale

Like other elements in Blender, points and strokes can be
moved `G`, rotated `R` or scaled `S` as described in
the [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.html) section.
When in *Edit Mode*,
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.html)
is also available for the transformation actions.

### Transform Snapping

Basic move, rotate and scale transformations for selected points/strokes.
See [Move, Rotate, Scale Basics](../../../modeling/meshes/editing/mesh/transform/basic.html) for more information.

### Tools

The *Bend*, *Shear*, *To Sphere*, *Extrude* and *Shrink Fatten* transform tools are described
in the [Editing tools](tools/index.html) section.
user: Provide the full official documentation entry for Paragraph, preserving all code examples.

assistant: The *Paragraph* Panel has settings for the alignment and spacing of text.

[image reference removed]

The Paragraph panel.

### Alignment

Horizontal
:   Left:
    :   Aligns text to the left of the frames when using them,
        else uses the origin of the text object as the starting point of the text (which grows to the right).

    Center:
    :   Centers text in the frames when using them,
        else uses the origin of the text object as the mid-point of the text
        (which grows equally to the left and right).

    Right:
    :   Aligns text to the right of the frames when using them,
        else uses the origin of the text object as the ending point of the text (which grows to the left).

    Justify:
    :   Only flushes a line when it is terminated by a word wrap (**not** by a newline),
        and uses *whitespace* instead of *character spacing* (kerning) to fill lines.

    Flush:
    :   Always flushes the line, even when it is still being typed-in.
        It uses character spacing (kerning) to fill lines.

Vertical
:   Top:
    :   - With text boxes, aligns the top of the text to the top of the frames.
        - With no text box, aligns the top of the text to the origin of the object, and grows to the bottom.

    Top Baseline:
    :   - With text boxes, aligns the ‘top’ baseline of the text to the top of the frames.
        - With no text box, aligns the actual baseline of the text to the origin of the object,
          and grows to the bottom.

    Middle:
    :   - With text boxes, centers the text in the frames.
        - With no text box, centers the text on the origin of the object,
          and grows in both top and bottom directions equally.

    Bottom Baseline:
    :   - With text boxes, aligns the baseline of the text to the bottom of the frames.
        - With no text box, aligns the baseline of the text to the origin of the object, and grows to the top.

    Bottom:
    :   - With text boxes, align the bottom of the text to the bottom of the frames.
        - With no text box, align the bottom of the text to the origin of the object, and grows to the top.

### Spacing

Character Spacing
:   A factor by which space between each character (kerning) is scaled in width.

    In Edit Mode in the 3D Viewport, you can also control individual kerning
    at text cursor position by pressing `Alt`-`Left` / `Alt`-`Right` to decrease/increase it.

Word Spacing
:   A factor by which whitespace between words is scaled in width.

Line Spacing
:   A factor by which the vertical space between lines is scaled.

Offset X, Y
:   These settings control the X and Y offset of the text position within the object.
    This applies relatively to the object’s origin, either to the whole text or, when using text boxes, to each frame.
user: Show practical ways to work with GlowStrip(EffectStrip) in a Blender add-on or script – include code.

assistant: # GlowStrip(EffectStrip)

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

*class* bpy.types.GlowStrip(*EffectStrip*)
:   Sequence strip creating a glow effect

    blur_radius
    :   Radius of glow effect

        Type:
        :   float in [0.5, 20], default 0.0

    boost_factor
    :   Brightness multiplier

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

    clamp
    :   Brightness limit of intensity

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

    input_1
    :   First input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

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

    quality
    :   Accuracy of the blur effect

        Type:
        :   int in [1, 5], default 0

    threshold
    :   Minimum intensity to trigger a glow

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

    use_only_boost
    :   Show the glow buffer only

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

assistant: # Clay

Similar to the [Draw](draw.xhtml) brush,
but includes settings to adjust the [sculpt plane](../../brush/brush_settings.xhtml#bpy-types-brush-sculpt-plane)
on which the brush acts. That’s because it behaves like a combination of the
[Plane](plane.xhtml) and *Draw* brushes.

This brush is useful for building and removing volumes and shapes like real clay,
because it flattens details as you add/subtract from the surfaces.

If used together with [Dyntopo](../tool_settings/dyntopo.xhtml#bpy-ops-sculpt-dynamic-topology-toggle)
it’s easy to continuously build shapes, even in a single stroke.
user: Explain Behavior in complete detail according to the official Blender documentation.

assistant: When executed, this node evaluates the connected closure’s internal node graph.
All input values are passed into the closure by name, and all resulting values are returned through the corresponding
outputs.

If no closure is connected, or if the node is muted, *Evaluate Closure* automatically passes through any matching
inputs and outputs by name. This *pass-through mode* makes closures optional and allows node groups to function even
without one.

Evaluation occurs in the local context of the node tree where *Evaluate Closure* resides, inheriting relevant fields,
attributes, and geometry data.
user: How do I use Perlin Noise 2D in Blender? Include parameters, examples, warnings and best practices.

assistant: # Perlin Noise 2D

The *Perlin Noise 2D* modifier adds one-dimensional Perlin noise to the stroke. The modifier generates
noisy displacements using 2D coordinates of stroke vertices as the input of the noise generator.

Frequency
:   How dense the noise is (kind of a scale factor along the stroke).

Amplitude
:   How much the noise distorts the stroke in the *Angle* direction.

Seed
:   The seed of the random generator (the same seed over a stroke will always give the same result).

Octaves
:   The “level of detail” of the noise.

Angle
:   In which direction the noise is applied (0.0 is fully horizontal).
user: How do I use MovieTrackingMarkers(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MovieTrackingMarkers(bpy_struct)

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

*class* bpy.types.MovieTrackingMarkers(*bpy_struct*)
:   Collection of markers for movie tracking track

    find_frame(*frame*, *\**, *exact=True*)
    :   Get marker for specified frame

        Parameters:
        :   - **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to find marker for
            - **exact** (*boolean**,* *(**optional**)*) – Exact, Get marker at exact frame number rather than get estimated marker

        Returns:
        :   Marker for specified frame

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

    insert_frame(*frame*, *\**, *co=(0.0, 0.0)*)
    :   Insert a new marker at the specified frame

        Parameters:
        :   - **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to insert marker to
            - **co** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-1, 1], (optional)) – Coordinate, Place new marker at the given frame using specified in normalized space coordinates

        Returns:
        :   Newly created marker

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

    delete_frame(*frame*)
    :   Delete marker at specified frame

        Parameters:
        :   **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to delete marker from

    *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 Transform: syntax, arguments, return values, common patterns.

assistant: A Bézier curve can be edited by transforming the locations of both control points and handles.
NURBS curve on the other hand have only control points.

Move, Rotate, Scale
:   Like other elements in Blender, curve control points and handles can be
    moved, rotated, or scaled as described in
    [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml).

To Sphere, Shear, Bend, Push/Pull, Warp, Randomize
:   The transform tools are described in
    the [Transformations](../../meshes/editing/mesh/transform/index.xhtml) sections.

Move/Scale Texture Space
:   Like other objects, curves have textures spaces which can be
    [edited](../../meshes/uv/uv_texture_spaces.xhtml#properties-texture-space-editing).

### Radius

Controls the width of the extrusion along the “spinal” curve.
The radius will be interpolated from point to point (you can check it with the normals).
The *Radius* of the points is set using the *Radius* transform tool. Or in the Sidebar *Transform* panel.

[image reference removed]

One control point radius set to zero.
user: Give a detailed overview of GeometryNodeInputNamedAttribute(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeInputNamedAttribute(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.GeometryNodeInputNamedAttribute(*GeometryNode*)
:   Retrieve the data of a specified attribute

    data_type
    :   The data type used to read the attribute values

        Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Navigating

As with most editors, you can:

- Pan the view vertically (channels) and horizontally (time) by dragging `MMB`.
- Zoom in and out by rolling `Wheel` or dragging `Ctrl`-`MMB`.

You can also use the scrollbars for this.
user: Explain Piston Constraint in complete detail according to the official Blender documentation.

assistant: # Piston Constraint

A piston permits translation along the X axis of the constraint object.
It also allows rotation around the X axis of the constraint object.
It is like a combination of the freedoms of a slider with the freedoms of a hinge
(neither of which is very free alone).
user: How do I use Curves in Blender? Include parameters, examples, warnings and best practices.

assistant: # Curves

These are global settings that apply to all instances of particle hair systems.
The resolution of the strands is controlled by the step values in particle settings.
Each hair system uses the material identified in the particle settings.

Shape
:   Controls how curves (such as hair strands) are represented during rendering.
    Different methods balance speed and accuracy,
    depending on whether the curves are viewed up close or in the distance.

    Rounded Ribbons:
    :   Render curves as flat ribbon with rounded normals, for fast rendering.
        Curves are subdivided with a fixed number of specified subdivisions.

        Curve Subdivisions
        :   Number of subdivisions used in cardinal curve intersection (power of 2).

    3D Curves:
    :   Render curves as circular 3D geometry, for accurate results when viewing curves close up.
        Curves are automatically subdivided until the curve is smooth.

    Linear 3D Curves:
    :   Render curves as 3D circular geometry with linear interpolation between control points.
        This is faster than full 3D curves but less smooth, and may show visible corners at low resolutions.

        This is an optimization to take advantage of hardware accelerated curve intersection on GPUs.
        Results will not look exactly the same on different CPU and GPU devices, so this is not
        suitable for multi device rendering or render farms with mixed hardware.