PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Color Attributes: syntax, arguments, return values, common patterns.

assistant: Color data can be applied directly to an object’s vertices rather than using a texture or a material.
There are two modes to paint color attributes in.
Use [Vertex Paint](../../../sculpt_paint/vertex_paint/index.xhtml) mode to paint per face corner
by enabling the paint mask in the header.
This is useful to achieve sharp edges in the color attribute on low-poly assets.
Alternatively use Sculpt mode to paint on a much higher vertex count.

### Creating a New Color Attribute

To create a new Color Attribute select the plus icon next to the list of attributes.
This action will open a pop-up with the following information.

Name
:   The name of the Color Attribute which can be referenced elsewhere in Blender.

Domain
:   The associated part of the geometry that stores the attribute.
    See [Attribute Domains](../../geometry_nodes/attributes_reference.xhtml#attribute-domains) for more information.

    Vertex:
    :   Color Attributes are stored per each vertex.

    Face Corner:
    :   Color Attributes are stored per each corner of a face.

Data Type
:   The data type to represent colors internally.

    Color:
    :   RGBA color with floating-point precision.

    Byte Color:
    :   RGBA color with 8-bit precision.

Color
:   The default color to fill for every element in the domain.

### Color Attribute Specials

These are operators that are available in the menu to the right of the attribute list.

Duplicate Color Attribute
:   Creates a copy of the active color attribute in the list.

Convert Color Attribute
:   Changes how the color attribute is stored.

    Domain
    :   The associated part of the geometry that stores the attribute.
        See [Attribute Domains](../../geometry_nodes/attributes_reference.xhtml#attribute-domains) for more information.

        Vertex:
        :   Color Attributes are stored per each vertex.

        Face Corner:
        :   Color Attributes are stored per each corner of a face.

    Data Type
    :   The data type to represent colors internally.

        Color:
        :   RGBA color with floating-point precision.

        Byte Color:
        :   RGBA color with 8-bit precision.
user: Explain Symmetrize in complete detail according to the official Blender documentation.

assistant: # Symmetrize

The *Symmetrize* tool is a quick way to make a mesh symmetrical.
*Symmetrize* works by cutting the mesh at the pivot point of the object,
and mirroring over the geometry in the specified axis, and merges the two halves together
(if they are connected). Also the mesh data is copied from one side to the other:
e.g. UVs, colors attributes, vertex weights.

Direction
:   Specify the axis and direction of the effect. Can be any of the three axes,
    and either positive to negative, or negative to positive.

Threshold
:   The vertices in this range will be snapped to the plane of symmetry.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_symmetrize_example-1.png   Mesh before Symmetrize. | ../../../../_images/modeling_meshes_editing_mesh_symmetrize_example-2.png   Mesh after Symmetrize. |
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   Standard geometry input.

Capture Items
:   The fields to store. Inputs can be added by connecting another node’s output
    to this node’s blank input, or by using the *Capture Items* list in the node’s
    *Properties* panel.

    The inputs can be renamed by clicking them with `Ctrl`-`LMB` in the node
    itself or in its *Capture Items* list. The latter also accepts double clicking.
user: Show practical ways to work with Sculpting Options in a Blender add-on or script – include code.

assistant: Selection Mask
:   Sculpt Mode in Grease Pencil allows you to select points or strokes to restrict the effect
    of the sculpting tools to only a certain areas of your drawing.

    You can use the selection tools in the Toolbar for a quick selection.
    You can restrict sculpting only on the selected points or strokes with the Selection mode buttons.
    The three modes can be toggled with `1`, `2`, or `3` respectively.

Multiframe
:   Sometimes you may need to modify several frames at the same time with the sculpting tools.

    You can activate multiframe editing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../../multiframe.html) for more information.
user: Explain Asset Operators in complete detail according to the official Blender documentation.

assistant: Brushes can be managed through a few operators that let Blender handle the act of saving and
updating the brushes in asset libraries for you. Assets managed this way will be saved in special
[asset system files](../../files/asset_libraries/introduction.xhtml#asset-system-files) using a .asset.blend file extension.

[image reference removed]

Brush Asset panel in the Sidebar showing asset operators.

Duplicate Asset…
:   Creates a copy of the currently active brush as asset, and activates it. A popup is spawned to input some settings
    to use:

    Name
    :   A custom name to use for the new brush.

    Library
    :   Choose an Asset Library to store the new brush asset in. The available asset libraries are configured
        [in the Preferences](../../editors/preferences/file_paths.xhtml#bpy-types-userassetlibrary).

    Catalog
    :   Choose an [Asset Catalog](../../files/asset_libraries/catalogs.xhtml) to assign the brush asset to. Entering a
        non-existent name/path will create a new catalog accordingly.

Delete Asset
:   Permanently remove this brush asset from the Asset Library it is stored in. This cannot be undone, so a popup will
    ask for confirmation.

Edit Metadata…
:   Spawns a popup to change some of the available [asset metadata](../../editors/asset_browser.xhtml#editing-asset-metadata) fields:

    Catalog
    :   Choose an [Asset Catalog](../../files/asset_libraries/catalogs.xhtml) to assign the brush asset to. Entering a
        non-existent name/path will create a new catalog accordingly.

    Author
    :   See [Asset Author](../../editors/asset_browser.xhtml#bpy-types-assetmetadata-description).

    Description
    :   See [Asset Description](../../editors/asset_browser.xhtml#bpy-types-assetmetadata-description).

Edit Preview Image…
:   Opens a window with the File Browser to select an image for the asset preview.

Save Changes to Asset
:   Saves any changes made to the active brush to the asset library.

Revert to Asset
:   Discards any unsaved changes made to the brush asset.
user: Give a detailed overview of Preview: syntax, arguments, return values, common patterns.

assistant: # Preview

The Preview panel gives a quick visualization of the active material applied in a simple scene.

Shape
:   Preview the material on a Plane, Sphere, Cube, Hair, Shader Ball, Cloth or Fluid object.
    This shape is also used for previews when linking and appending materials.

Preview World Cycles Only
:   Use the world from the current scene for lighting in the material preview.

[image reference removed]

Preview shapes.
user: Show practical ways to work with Modifier Shrinkwrap Mode Items in a Blender add-on or script – include code.

assistant: # Modifier Shrinkwrap Mode Items

ON_SURFACE:
:   On Surface.

    The point is constrained to the surface of the target object, with distance offset towards the original point location.

INSIDE:
:   Inside.

    The point is constrained to be inside the target object.

OUTSIDE:
:   Outside.

    The point is constrained to be outside the target object.

OUTSIDE_SURFACE:
:   Outside Surface.

    The point is constrained to the surface of the target object, with distance offset always to the outside, towards or away from the original location.

ABOVE_SURFACE:
:   Above Surface.

    The point is constrained to the surface of the target object, with distance offset applied exactly along the target normal.
user: Give a detailed overview of Displace Geometry Node: syntax, arguments, return values, common patterns.

assistant: # Displace Geometry Node

[image reference removed]

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

assistant: Text
:   The actual text displayed.
    Text is limited to 512 characters.

Wrap Width
:   Wraps the text by the percentage of the frame width,
    setting this to zero disables word wrapping.

### Style

Font
:   [Data-Block Menu](../../../../interface/controls/templates/data_block.xhtml#ui-data-block) to choose which font-file is used to render the text.

    (Bold)
    :   Use a bold font face with a strong/thick visual appearance.

    (Italic)
    :   Use an italicized font face with a slanted visual appearance.

Size
:   Size of the text.

Color
:   The text color.

#### Outline

Creates a line enclosing the shape of the text.

Color
:   The color and opacity of the outline.

Width
:   The thickness of the outline.

#### Shadow

Creates a shadow under the text.

Color
:   The color and opacity of the shadow.

Angle
:   Defines the position of the shadow as an angle, 0° being to the right and 90° being below.

Offset
:   Amount to shift the shadow compared to the normal text.

Blur
:   Amount to blur the shadow.

#### Box

Creates a background for the text to improve the readability and clarity of text in some situations.

Color
:   The color and opacity of the box.

Margin
:   The distance the box boundaries extends from the boundaries of the font glyphs.
    The distance is measured as a factor of the image’s width.

Roundness
:   Rounds the corners of the box, defined as a factor of box height.

### Layout

Location X, Y
:   Positions the text on the X, Y axis.

Alignment X, Y
:   Controls the horizontal positioning of text within the text strip.
    The text content can be aligned to the left, center, or right.

Anchor X, Y
:   Horizontal (X) or vertical (Y) “origin” of the text relative to the location.
user: What is Text & Search Fields and how is it used in Blender Python scripting?

assistant: [image reference removed]

A text and a search field.

Text fields show a rounded rectangular border, and optionally an icon and/or text inside the border.
Text fields store text strings, and provide the means to edit text by standard text editing shortcuts:

|  |  |
| --- | --- |
| `Home` | Go to the start of the line. |
| `End` | Go to the end of the line. |
| `Left`, `Right` | Move the cursor a single character. |
| `Ctrl`-`Left`, `Ctrl`-`Right` | Move the cursor an entire word. |
| `Backspace`, `Delete` | Delete characters. |
| `Ctrl`-`Backspace`, `Ctrl`-`Delete` | Delete words. |
| `Shift` | Select while holding the key and moving the cursor. |
| `Ctrl`-`A` | Select all text. |
| `Ctrl`-`C` | Copy the selected text. |
| `Ctrl`-`X` | Cut the selected text. |
| `Ctrl`-`V` | Paste text at the cursor position. |

For text fields with an icon and pop-ups, see [Data ID](../templates/data_block.xhtml#ui-data-id).
user: Show practical ways to work with Group Input in a Blender add-on or script – include code.

assistant: Exposes the inputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
bringing in each input right where you need it (rather than dragging long links all across your graph).

The input slots can be edited in the *Group* tab of the *Sidebar*.
user: Explain Sequencer Overlays in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Overlays are information that is displayed on top of the sequencer region.
Clicking  (Show Overlays) toggles all overlays in one go,
while the drop-down button shows a pop-over where you can toggle individual ones:

Grid
:   Shows vertical lines at regular time intervals.

Cache
:   Visualize cached images on the timeline.

### Strips

Name
:   Shows the [Name](sidebar/strip.xhtml#bpy-types-strip-name) of each strip.

Source
:   Shows the file path of each strip.

Duration
:   Shows the length of each strip (in frames).

Animation Curves
:   Shows animation curves for volume (Sound strips) and opacity (other strips).

Thumbnails
:   Displays thumbnails across the full width of each Movie or Image strip.
    The thumbnail size depends on the vertical zoom level (which can be adjusted
    by dragging up and down with `Ctrl`-`MMB`). Zooming in results in taller
    strips with bigger, but fewer thumbnails. Zooming out results in narrower
    strips with smaller, but more thumbnails.

Color Tags
:   Displays each strip in its designated custom color (if applied) rather than a
    [color representing its type](../../../video_editing/edit/montage/strips/introduction.xhtml#sequencer-strip-colors). To set a custom color,
    either click the *Color Tag* button next to the strip’s name in
    Sidebar ‣ Strip, or use *Set Color Tag* in the strip’s context menu.

Offsets
:   Shows overflow bars of content that was trimmed from the strip (by moving
    the strip’s handles). See [Strip Offset Start/End](sidebar/strip.xhtml#bpy-types-strip-frame-offset-start).

### Waveforms

Type
:   Global options for waveform display on Sound strips.

    On:
    :   Enable waveforms for all strips.

    Strip:
    :   Use the [Display Waveform](sidebar/strip.xhtml#bpy-types-soundstrip-show-waveform)
        option of each individual strip.

    Off:
    :   Disable waveforms for all strips.

Style
:   How Waveforms are displayed.

    Full:
    :   Displays the audio amplitude.

    Half:
    :   Displays the audio level.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Mask
:   A grayscale image.

Size
:   The size of the surrounding area to look at for each pixel; or in other words, how much to
    dilate (for positive values) or erode (for negative values) the mask.

Type
:   Steps:
    :   Sets each pixel to the maximum (for dilation) or minimum (for erosion) value that’s found
        within a square surrounding it. This approach keeps the original gray levels and is best
        suited for masks that contain sharp corners; rounded shapes such as circles will look more
        square-like in the output.

        Despite the name, this is not an iterative process; the dilation/erosion is only performed
        once regardless of the chosen *Size*.

    Threshold:
    :   Makes all the pixels fully black or white depending on whether they’re darker or brighter
        than 50% gray. Then, sets each pixel to the maximum (for dilation) or minimum
        (for erosion) value that’s found within a circle surrounding it. This approach loses the
        original gray levels. Shape wise, it’s well-suited for masks that contain rounded corners;
        sharp ones will be rounded off.

    Distance:
    :   Sets each pixel to the maximum (for dilation) or minimum (for erosion) value that’s found
        within a circle surrounding it. This approach preserves the original gray levels and
        is well-suited for masks that contain rounded corners.

    Feather:
    :   Blurs the image.

Falloff Size Threshold
:   Determines how much to blur the edges after dilation/erosion.

Falloff Feather
:   Determines the brightness curve of the blurred edges.
user: Describe Import VDB Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Import VDB Node

[image reference removed]

The *Import VDB* node loads volumetric data from a .vdb file
and outputs it as a [Volume](../../../volumes/introduction.html) geometry.
All grids present in the file are loaded and included in the resulting volume.

This node is useful for importing simulation data or procedural volumes created in external software.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Tangent
:   The tangent direction vector derived from the input UV map.
    The output is a normalized vector field that lies along the surface and
    indicates the direction of increasing *U* values in the UV space.
    It can be combined with normals and bitangents for constructing a complete tangent space basis.
user: How do I use Extrude Edges in Blender? Include parameters, examples, warnings and best practices.

assistant: # Extrude Edges

Extrude edges as individual edges.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_extrude-edges_before.png   Edge selected. | ../../../../_images/modeling_meshes_editing_edge_extrude-edges_after.png   Edge extruded. |
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`StripModifier.name`](bpy.types.StripModifier.html#bpy.types.StripModifier.name "bpy.types.StripModifier.name") - [`StripModifier.type`](bpy.types.StripModifier.html#bpy.types.StripModifier.type "bpy.types.StripModifier.type") - [`StripModifier.mute`](bpy.types.StripModifier.html#bpy.types.StripModifier.mute "bpy.types.StripModifier.mute") - [`StripModifier.enable`](bpy.types.StripModifier.html#bpy.types.StripModifier.enable "bpy.types.StripModifier.enable") - [`StripModifier.show_expanded`](bpy.types.StripModifier.html#bpy.types.StripModifier.show_expanded "bpy.types.StripModifier.show_expanded") | - [`StripModifier.input_mask_type`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_type "bpy.types.StripModifier.input_mask_type") - [`StripModifier.mask_time`](bpy.types.StripModifier.html#bpy.types.StripModifier.mask_time "bpy.types.StripModifier.mask_time") - [`StripModifier.input_mask_strip`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_strip "bpy.types.StripModifier.input_mask_strip") - [`StripModifier.input_mask_id`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_id "bpy.types.StripModifier.input_mask_id") - [`StripModifier.is_active`](bpy.types.StripModifier.html#bpy.types.StripModifier.is_active "bpy.types.StripModifier.is_active") |
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Mode
:   How to link to OSL shaders.

    Internal:
    :   A text data-block is used to store the OSL shader, and the OSO bytecode is stored in the node itself.
        This is useful for distributing a blend-file with everything packed into it.

        Script Node Update
        :   Reloads the text file data-block, creating new inputs and outputs if needed.

    External:
    :   Used to specify a `.osl` file from a drive,
        and this will then be automatically compiled into a `.oso` file in the same directory.
        It is also possible to specify a path to a `.oso` file, which will then be used directly,
        with compilation done manually by the user. The third option is to specify just the module name,
        which will be looked up in the shader search path.

        The shader search path is located in the same place as the scripts or configuration path, under:

        **Linux:**

        ```
        $HOME/.config/blender/5.0/shaders/
        ```

        **Windows:**

        ```
        C:\Users\$user\AppData\Roaming\Blender Foundation\Blender\5.0\shaders\
        ```

        **macOS:**

        ```
        /Users/$USER/Library/Application Support/Blender/5.0/shaders/
        ```
user: Describe VertexGroupElement(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # VertexGroupElement(bpy_struct)

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

*class* bpy.types.VertexGroupElement(*bpy_struct*)
:   Weight value of a vertex in a vertex group

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

    weight
    :   Vertex Weight

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Generates a mask with random values for the entire object based on different mesh data.

Per Vertex
:   Assigns a random mask value for each vertex.

Per Face Set
:   Assigns a random mask value for each [Face Set](face_sets.xhtml).

Per Loose Mask
:   Assigns a random mask value for each disjoint part of the mesh.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: The image below shows the difference between rotating an object
around the 3D Cursor (left) and rotating it around the
[Median Point](median_point.xhtml) (right).

[image reference removed]

Rotation around the 3D Cursor compared to the Median Point.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Attribute.name`](bpy.types.Attribute.html#bpy.types.Attribute.name "bpy.types.Attribute.name") - [`Attribute.data_type`](bpy.types.Attribute.html#bpy.types.Attribute.data_type "bpy.types.Attribute.data_type") - [`Attribute.storage_type`](bpy.types.Attribute.html#bpy.types.Attribute.storage_type "bpy.types.Attribute.storage_type") | - [`Attribute.domain`](bpy.types.Attribute.html#bpy.types.Attribute.domain "bpy.types.Attribute.domain") - [`Attribute.is_internal`](bpy.types.Attribute.html#bpy.types.Attribute.is_internal "bpy.types.Attribute.is_internal") - [`Attribute.is_required`](bpy.types.Attribute.html#bpy.types.Attribute.is_required "bpy.types.Attribute.is_required") |
user: How do I use Selection in Blender? Include parameters, examples, warnings and best practices.

assistant: Splits (disconnects) the selection from the rest of the mesh.
The border edge to any non-selected elements are duplicated.

Note that the “copy” is left exactly at the same position as the original, so you must move it
`G` to see it clearly…
user: Describe Density from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Decimate

Simplifies an F-Curve by removing the keyframes that influence its shape the least.

Mode
:   How to pick the number of keyframes to delete.

    Ratio
    :   Deletes a certain percentage of keyframes.

        Remove
        :   The percentage of keyframes to remove.

    Error Margin
    :   Deletes as many keyframes as possible while ensuring the F-Curve’s shape changes
        no more than a certain amount.

        Max Error Margin
        :   How much the decimated curve may deviate from the original.

### Bake Keyframes

Creates a keyframe at every frame.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_sample.png   F-Curve before baking. | ../../../_images/editors_graph-editor_fcurves_editing_sample2.png   F-Curve after baking. |

### Clean Keyframes

Finds redundant keyframes among the selected ones and deletes them. A keyframe is seen as
redundant if it has the same value as its neighbors – even if the curve segments around it
aren’t flat.

Threshold
:   Value threshold. By increasing this, you can also delete keyframes that *almost* have the
    same value as their neighbors.

Channels
:   Cleans all the keyframes (even unselected ones) in the selected F-Curves.
    If a curve is left with only one keyframe, it’s deleted entirely.

|  |  |
| --- | --- |
| ../../../_images/editors_graph-editor_fcurves_editing_clean1.png   F-Curve before cleaning. | ../../../_images/editors_graph-editor_fcurves_editing_clean2.png   F-Curve after cleaning. |
user: Give a detailed overview of bpy_extras submodule (bpy_extras.image_utils): syntax, arguments, return values, common patterns.

assistant: # bpy_extras submodule (bpy_extras.image_utils)

bpy_extras.image_utils.load_image(*imagepath*, *dirname=''*, *place_holder=False*, *recursive=False*, *ncase_cmp=True*, *convert_callback=None*, *verbose=False*, *relpath=None*, *check_existing=False*, *force_reload=False*)
:   Return an image from the file path with options to search multiple paths
    and return a placeholder if its not found.

    Parameters:
    :   - **filepath** (*str*) – The image filename
          If a path precedes it, this will be searched as well.
        - **dirname** (*str*) – is the directory where the image may be located - any file at
          the end will be ignored.
        - **place_holder** (*bool*) – if True a new place holder image will be created.
          this is useful so later you can relink the image to its original data.
        - **recursive** (*bool*) – If True, directories will be recursively searched.
          Be careful with this if you have files in your root directory because
          it may take a long time.
        - **ncase_cmp** (*bool*) – on non windows systems, find the correct case for the file.
        - **convert_callback** (*function*) – a function that takes an existing path and returns
          a new one. Use this when loading image formats blender may not support,
          the CONVERT_CALLBACK can take the path for a GIF (for example),
          convert it to a PNG and return the PNG’s path.
          For formats blender can read, simply return the path that is given.
        - **relpath** (*str* *|* *None*) – If not None, make the file relative to this path.
        - **check_existing** (*bool*) – If true,
          returns already loaded image data-block if possible
          (based on file path).
        - **force_reload** (*bool*) – If true,
          force reloading of image (only useful when `check_existing`
          is also enabled).

    Returns:
    :   an image or None

    Return type:
    :   [`bpy.types.Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image") | None
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: ### Absorption

Coefficients
:   Probability density per color channel that light is absorbed per unit distance traveled in the medium.
    It is equivalent to \((1-\text{Color}) \times \text{Density}\) in
    [Volume Absorption](volume_absorption.xhtml#bpy-types-shadernodevolumeabsorption).

### Scatter

Coefficients
:   Probability density per color channel of an out-scattering event occurring per unit distance traveled in the
    medium. It is equivalent to \(\text{Color} \times \text{Density}\) in
    [Volume Scatter](volume_scatter.xhtml#bpy-types-shadernodevolumescatter).

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.

### Emission

Coefficients
:   Emitted radiance per color channel that is added to a ray per unit distance.
    It is equivalent to \(\text{Color} \times \text{Strength}\) in [Emission](emission.xhtml#bpy-types-shadernodeemission).
user: Explain PointerProperty(Property) in complete detail according to the official Blender documentation.

assistant: # PointerProperty(Property)

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

*class* bpy.types.PointerProperty(*Property*)
:   RNA pointer property to point to another RNA struct

    fixed_type
    :   Fixed pointer type, empty if variable type

        Type:
        :   [`Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), (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: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The NonLinear Animation editor, or NLA editor for short, lets you animate on a higher level.
Instead of working with individual keyframes, it works with [actions](../../animation/actions.html),
which are named, reusable animation segments.

[image reference removed]

The NLA editor.
user: How do I use GeometryNodeGroup(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeGroup(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.GeometryNodeGroup(*GeometryNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

    *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 Blender Landmarks in Blender? Include parameters, examples, warnings and best practices.

assistant: Each Open Project places new demands on Blender as a 3D creation suite, which in turn leads to further upgrades. While
a complete list of updates is beyond the scope of this article, some milestones are worth noting.

Early 2008 saw the start of the Blender 2.5 project. This combined a major User Interface overhaul, with new tool
definitions, a data access system, event handling, and a new animation system. For 2.5, the primary goal was to bring
the interface standards and input methods up to date.

Cycles is Blender’s production-capable path-tracing render engine, first incorporated into release 2.61, back in 2011.
Over the years, Cycles has introduced support for a wide range of rendering possibilities, including AMD and NVIDIA.
Similarly, it’s grown to include support for many features including hair, motion blur, smoke and fire, major shaders
and materials, adaptive subdivisions, and much more.

With its watershed 2.8 release in July, 2019, Blender broke into the 3D mainstream. Starting with a drastically
revamped User Interface, the 2.8 series included a multitude of innovations, from EEVEE (a real-time render engine),
to new remeshing options for sculptors, to the integration of Mantaflow, to a fully functioning 2D animation workspace
that also offered the possibility of a 2D/3D hybrid workflow.

Although industry recognition for Blender had grown over the decades, 2.8 marked the moment when it was widely
accepted as a legitimate alternative to paid competitors. As well as using Blender in their own projects, some of the
world’s largest and most recognized companies became regular contributors to the Blender Development Fund, ensuring
that Blender can continue to innovate.

As well as Blender and Open Projects made with Blender, there’s Blender Cloud. This subscription-based Open Production
platform provides rolling updates on current Open Movie projects, as well as an archive of film assets in .blend file
form, animation and shot breakdowns, shaders and textures, and comprehensive training videos from professional artists
and developers, often those employed at Blender HQ in Amsterdam.
user: Show practical ways to work with Distance from Camera in a Blender add-on or script – include code.

assistant: # Distance from Camera

The *Distance from Camera* modifier alters the base property with a new one
from a given range using the distance to the active *camera*.

Range Min, Max
:   The limits of the mapping from “distance to camera” to “property in mapping”.
    If the current point of the stroke is at *Range Min* or less from the active camera or the object,
    it will take the start value. And conversely,
    if it is at *Range Max* or more from the camera/object, it will take the end value.
    These values are in the current scene’s units, not in pixels!

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Displacement
:   Input of the displacement map.
    If the input is color it’s implicitly converted in the vector input,
    the first channel (red) value determines displacement along X axis.
    The second channel (green) the displacement along Y axis.
    If the input is a grayscale image, where both the channel values are equal,
    the input image will be displaced equally in both X and Y directions.

### Sampling

Interpolation
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Describe Dependency graph: Simple exporter from the Blender manual or Python API, including usage steps and snippets.

assistant: This example is a combination of all previous ones, and shows how to write a simple exporter
script.

```
import bpy

class OBJECT_OT_simple_exporter(bpy.types.Operator):
    """Simple (fake) exporter of selected objects"""
    bl_label = "DEG Export Selected"
    bl_idname = "object.simple_exporter"

    apply_modifiers: bpy.props.BoolProperty(name="Apply Modifiers")

    def execute(self, context):
        depsgraph = context.evaluated_depsgraph_get()
        for object_instance in depsgraph.object_instances:
            if not self.is_object_instance_from_selected(object_instance):
                # We only export selected objects.
                continue
            # NOTE: This will create a mesh for every instance, which is not ideal at all. In
            # reality destination format will support some sort of instancing mechanism, so the
            # code here will simply say "instance this object at object_instance.matrix_world".
            mesh = self.create_mesh_for_object_instance(object_instance)
            if mesh is None:
                # Happens for non-geometry objects.
                continue
            print(f"Exporting mesh with {len(mesh.vertices)} vertices "
                  f"at {object_instance.matrix_world}")

            self.clear_mesh_for_object_instance(object_instance)

        return {'FINISHED'}

    def is_object_instance_from_selected(self, object_instance):
        # For instanced objects we check selection of their instancer (more accurately: check
        # selection status of the original object corresponding to the instancer).
        if object_instance.parent:
            return object_instance.parent.original.select_get()
        # For non-instanced objects we check selection state of the original object.
        return object_instance.object.original.select_get()

    def create_mesh_for_object_instance(self, object_instance):
        if self.apply_modifiers:
            return object_instance.object.to_mesh()
        else:
            return object_instance.object.original.to_mesh()

    def clear_mesh_for_object_instance(self, object_instance):
        if self.apply_modifiers:
            return object_instance.object.to_mesh_clear()
        else:
            return object_instance.object.original.to_mesh_clear()

def register():
    bpy.utils.register_class(OBJECT_OT_simple_exporter)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_simple_exporter)

if __name__ == "__main__":
    register()
```
user: How do I use Stabilize 2D Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Stabilize 2D Node

[image reference removed]

Stabilizes the footage according to the settings set in
Movie Clip Editor ‣ Properties ‣ Stabilization ‣ 2D Stabilization.
For more information,
see [2D Stabilization](../../../movie_clip/tracking/clip/sidebar/stabilization/index.xhtml).
user: Give a detailed overview of Topology: syntax, arguments, return values, common patterns.

assistant: ### Loops

[image reference removed]

Edge and face loops.

*Edge* and *face* loops are sets of faces or edges that form continuous “loops” as shown in
Fig. [Edge and face loops.](#fig-mesh-topo-loop).

In the image above, loops that do not end in poles are cyclic (1 and 3).
They start and end at the same vertex and divide the model into two partitions.
Loops can be a quick and powerful tool to work with specific,
continuous regions of a mesh and are a prerequisite for organic character animation.
For a detailed description of how to work with loops in Blender, see:
[Select Edge Loops](selecting/loops.xhtml#bpy-ops-mesh-loop-multi-select).

Edge Loops

Loops (1 and 2) in Fig. [Edge and face loops.](#fig-mesh-topo-loop) are edge loops.
They connect vertices so that each one on the loop has exactly two neighbors that are not on
the loop and placed on both sides of the loop (except the start and end vertex in case of poles).

Edge loops are an important concept especially in organic (subsurface)
modeling and character animation. When used correctly, they allow you to build models with
relatively few vertices that look very natural when used as subdivision surfaces and
deform very well in animation.

Take Fig. [Edge and face loops.](#fig-mesh-topo-loop) in organic modeling as an example: the edge loops follow
the natural contours and deformation lines of the skin and the underlying muscles.
The loops are denser in areas that deform more when the character moves, for example at the shoulders or knees.

Further details on working with edge loops can be found in [Select Edge Loops](selecting/loops.xhtml#bpy-ops-mesh-loop-multi-select).

Face Loops

These are a logical extension of edge loops in that they consist of the faces between
two edge loops, as shown in loops (3 and 4) in Fig. [Edge and face loops.](#fig-mesh-topo-loop).
Note that for non-circular loops (4)
the faces containing the poles are not included in a face loop.

Further details on working with face loops can be found in
[Face Loop Selection](selecting/loops.xhtml#modeling-meshes-selecting-face-loops).

### Poles

See [N-poles & E-poles](https://blender.stackexchange.com/a/133676/55).

### Non-Manifold

See [Non-manifold](../../glossary/index.xhtml#term-Non-manifold).
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

The Volume Displace modifier.

Texture
:   The texture that is evaluated at every voxel to determine how far and in what direction to displace.

Strength
:   Controls how far voxels are displaced.

Sample Radius
:   Smaller values result in better performance, but might cut off the volume outside.

Mid Level
:   This should be modified if the texture offsets the entire volume in one direction and you want to center it again.
    For performance reasons, the displaced volume should stay close to its original position.
user: How do I use Multiresolution Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Multiresolution Modifier

The *Multiresolution* modifier (often shortened to “Multires”)
gives you the ability to subdivide a mesh similarly
to the [Subdivision Surface](subdivision_surface.xhtml) modifier,
but also allows you to edit the new subdivision levels in
[Sculpt Mode](../../../sculpt_paint/sculpting/introduction/adaptive.xhtml).

Deform modifiers will be applied onto the Multires subdivision levels instead of the base mesh,
if they come after the Multires.
user: What is Bone Collections and how is it used in Blender Python scripting?

assistant: # Bone Collections

[image reference removed]

The Bone Collections panel in the Armature properties.

This panel contains a Tree View to manage [Bone Collection](../bones/bone_collections.xhtml)
From this panel, Bone Collections can be created, deleted, re-arranged, and more.

Collections can be renamed by double clicking on the name, or right clinking and selecting *Rename*.
To nest a collection inside an existing collection, click and drag the name onto another collection’s name.
Child collection can also be made by `RMB` and selecting “Add Child Collection”.

To the right of the name gives a few controls of the collection:

Visible (Eye)
:   Bones in this collection will be visible in the 3D Viewport.

Solo (Star)
:   Show only this bone collection, and others also marked as “solo”.

Further more, collection that are not empty will have a dot to indicate the collection has bones assigned to it.
user: Describe Types from the Blender manual or Python API, including usage steps and snippets.

assistant: Besides standard markers, *pose markers* are another type of markers,
which are specific to armatures and shape keys.
They are used to denote poses in the Action Editor mode and Shape Keys Editor of Dope Sheet.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Vertex Count
:   This output is simply the number of sides of each face, or how many corners each face has.

Neighboring Face Count
:   The number of faces that connect to this face with at least one edge. On a regular manifold
    mesh with only quads and triangles, this will be the same as the vertex count, otherwise it might
    be completely different.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Action.pose_markers`](bpy.types.Action.html#bpy.types.Action.pose_markers "bpy.types.Action.pose_markers") - [`ActionPoseMarkers.active`](bpy.types.ActionPoseMarkers.html#bpy.types.ActionPoseMarkers.active "bpy.types.ActionPoseMarkers.active") - [`ActionPoseMarkers.new`](bpy.types.ActionPoseMarkers.html#bpy.types.ActionPoseMarkers.new "bpy.types.ActionPoseMarkers.new") - [`ActionPoseMarkers.remove`](bpy.types.ActionPoseMarkers.html#bpy.types.ActionPoseMarkers.remove "bpy.types.ActionPoseMarkers.remove") | - [`Scene.timeline_markers`](bpy.types.Scene.html#bpy.types.Scene.timeline_markers "bpy.types.Scene.timeline_markers") - [`TimelineMarkers.new`](bpy.types.TimelineMarkers.html#bpy.types.TimelineMarkers.new "bpy.types.TimelineMarkers.new") - [`TimelineMarkers.remove`](bpy.types.TimelineMarkers.html#bpy.types.TimelineMarkers.remove "bpy.types.TimelineMarkers.remove") |
user: How do I use Adaptive Domain in Blender? Include parameters, examples, warnings and best practices.

assistant: # Adaptive Domain

When enabled, the domain will adaptively shrink to best fit the gas,
saving computation time by leaving voxels without gas out of the simulation.
Unless the *Add Resolution* is used, the adaptive domain will not exceed the bounds of the original domain.

Add Resolution
:   Number of voxels to add around the outside of the domain.

Margin
:   Amount of extra space to leave around gas, measured in voxels.
    With very fast-moving gas larger margins may be required to prevent the gas from being cut off
    by the adaptive boundary, but note this will increase the number of voxels which need to be computed.

Threshold
:   Smallest amount of gas a voxel can contain before it is considered empty
    and the adaptive domain is allowed to cut it out of the simulation.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Mirror modifier.

Axis
:   The X, Y, Z axis along which to mirror, i.e. the axis perpendicular to the mirror plane of symmetry.

    To understand how the axis applies to the mirror direction, if you were to mirror on the X axis,
    the positive X values of the original stroke would become the negative X values on the mirrored side.

    You can select more than one of these axes. And will then get more mirrored copies.
    With one axis you get a single mirror, with two axes four mirrors, and with all three axes eight mirrors.

Object
:   A [Data ID](../../../interface/controls/templates/data_block.xhtml#ui-data-id) to select an object (usually an empty),
    which position and rotation will be used to define mirror planes
    (instead of using the ones from the modified object).

### Influence

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