PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Acceleration Structure and how is it used in Blender Python scripting?

assistant: Use Spatial Splits
:   Spatial splits improve the rendering performance in scenes with a mix of large and small polygons.
    The downsides are longer BVH build times and slightly increased memory usage.

Use Curves BVH
:   Use a special type of [BVH](../../../glossary/index.html#term-BVH) for rendering curves.
    The bounding boxes are not axis aligned allowing a spatially closer fit to the curve geometry.
    Disabling this option will reduce memory, at the cost of increasing curve render time.

BVH Time Steps
:   Split BVH primitives by this number of time steps to speed up render time at the expense of memory.

Use Compact BVH
:   Use a more compact BVH structure, which can reduce RAM usage but render slower.
user: Explain Offset Edge Slide in complete detail according to the official Blender documentation.

assistant: # Offset Edge Slide

Add two edge loops on either side of selected loops.

Cap Endpoint
:   Extends the loop by creating triangles at endpoints.

Factor
:   Location of the loop relative to the center loop and the outside edge loops.

Even
:   Only available for single edge loops.
    This matches the shape of the edge loop to one of the adjacent edge loops.
    (See [Edge Slide tool](edge_slide.xhtml#modeling-meshes-editing-edge-slide) for details.)

Flipped
:   When Even is enabled, this flips the target edge loop to match.
    (See [Edge Slide tool](edge_slide.xhtml#modeling-meshes-editing-edge-slide) for details.)

Clamp
:   Clamp within the edge extents.

Correct UVs
:   Correct UV coordinates when transforming.
user: How do I use Documenting New Features and Changes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Documenting New Features and Changes

With every Blender release, exciting new features, improvements, and changes are introduced. To ensure Blender users
can make the most of these updates, the documentation needs to be updated in parallel.

The Blender documentation project tracks changes requiring updates or additions to the manual. By contributing, you
help keep the manual accurate and valuable for the global Blender community.

This guide will walk you through the process of documenting these changes using release issues and commit logs.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Font
:   Font glyph used to generate the curve.

Overflow
:   Controls how the text fits inside the text box.

    Overflow:
    :   Wraps the text at the *Text Box Width*.

    Scale To Fit:
    :   Scales the text size to fit the *Text Box Width* and *Text Box Height*.

    Truncate:
    :   Only outputs text characters that fit within the width and height, based on the *Size* input.
        Any part of the string that did not fit is moved to the *Remainder* output.

Alignment
:   Controls horizontal alignment of text on each line.

    Left:
    :   Aligns the text to the left.

    Center:
    :   Aligns the text to the center.

    Right:
    :   Aligns the text to the right.

    Justify:
    :   Aligns the text to the left and right.

    Flush:
    :   Aligns the text to the left and right with equal character spacing.

Align Y
:   Controls vertical alignment of the block of text.

    Top:
    :   Aligns the text to the top.

    Top Baseline:
    :   Aligns the text to the top baseline.

    Middle:
    :   Aligns the text to the middle.

    Bottom Baseline:
    :   Aligns the text to the bottom baseline.

    Bottom:
    :   Aligns the text to the bottom.

Pivot Point
:   Controls where on each character the output *Pivot Point* is placed.

    Midpoint:
    :   Place the pivot points at the center of each character’s bounds.

    Top Left:
    :   Place the pivot points at the top left of each character’s bounds.

    Top Center:
    :   Place the pivot points at the middle of the top of each character’s bounds.

    Top Right:
    :   Place the pivot points at the top right of each character’s bounds.

    Bottom Left:
    :   Place the pivot points at the bottom left of each character’s bounds.

    Bottom Center:
    :   Place the pivot points at the middle of bottom of each character’s bounds.

    Bottom Right:
    :   Place the pivot points at the bottom right of each character’s bounds.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: The first three settings simulate the aperture of the camera.

Flaps
:   Sets an integer number of blades for the cameras iris diaphragm.

Angle
:   Gives these blades an angular offset relative to the image plane.

Roundness
:   Sets the curvature of the blades with (0 to 1) from straight to bringing them to a perfect circle.

Catadioptric Size
:   Provides a type of distortion found in mirror lenses and some telescopes.
    This can be useful to produce a visual complex bokeh.

Color Shift
:   Introduces chromatic aberration into the blur such as would be caused by a tilt-shift lens.
user: Explain A Bouncing Cube in complete detail according to the official Blender documentation.

assistant: ### The Process

First, change your start and end frames to 1 and 150.

Then, add a plane, and scale it five times. Next, go to the physics tab, and add a collision.
The default settings are fine for this example.

Now add a cube, or use the default cube, then enter *Edit Mode* to subdivide it three times.
Add a Bevel Modifier to it to smoothen the edges and then to add a little more,
press `R` twice, and move your cursor a bit.

When finished, your scene should look like this:

[[image reference removed]](../../_images/physics_soft-body_examples_scene-ready.png)

The scene, ready for soft body physics.

Everything is ready to add the soft body physics.
Go to Properties ‣ Physics and choose *Soft Body*.
Uncheck the *Soft Body Goal*, and check *Soft Body Self Collision*.
Also, under *Soft Body Edges*, increase the Bending to 10.

Playing the animation will now give a slow animation of a bouncing cube.
To speed things up, we need to bake the soft body physics.

Under *Soft Body Cache* change the values of your start and end frames. In this case 1 and 150.
Now, to test if everything is working, you can take a cache step of 5 or 10,
but for the final animation it is better to reduce it to 1, to cache everything.

When finished, your physics panel should look like this:

[image reference removed]

The physics cache settings.

[image reference removed]

The physics edges and self collision settings.

You can now bake the simulation, give the cube materials and textures and render the animation.

### The Result

[The rendered bouncing cube](https://www.youtube.com/watch?v=3PzgB9jw9iA)
user: How do I use Context-Sensitive Manual Access in Blender? Include parameters, examples, warnings and best practices.

assistant: You may want to access help for a tool or area from within Blender.

To do so, hover the cursor over the tool or button you need help with and use the keyboard shortcut or context menu
item to visit pages of this reference manual from within Blender. This opens a web page relating to the button under
the cursor, supporting both tool and value buttons.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Fill Type
:   How the circles at the top and bottom are filled with faces when their radius is larger than zero.

    None:
    :   Do not fill the circles.

    N-Gon:
    :   Fill the innermost segment of the circles with a single face.

    Triangles:
    :   Fill the innermost segment of the circles with triangles connected to a new vertex on the Z axis.
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: ### Brush Asset

The asset selector can be used to open a pop-up asset browser to select the active brush asset for the tool.

See [Asset Operators](../../../../sculpt_paint/brush/brush_management.xhtml#brush-management-utility-operators) for more information.

### Brush Settings

You can also configure the brush main settings exposed on the Tool Settings for convenience.

Direction `Ctrl`
:   The portion of area to fill.

    Normal:
    :   Fills the area inside the shape under the cursor.

    Inverted:
    :   When clicking outside the drawing, fills all shapes touching the area under the cursor.

Precision
:   Multiplier for fill boundary accuracy.
    Higher values are more accurate but slower.

Dilate/Contract
:   Size in pixels to expand or shrink the fill area from the strokes boundary.

Thickness
:   The thickness radius of the boundary stroke in pixels.

#### Advanced

Boundary
:   Sets the type of fill boundary limits calculation to perform.

    All:
    :   Use the thickness of the strokes and the editing lines together.

    Strokes:
    :   Use only the thickness of the strokes (ignore edit lines).

    Edit Lines:
    :   Use only the edit lines (ignore strokes).

    Show Lines (eye icon)
    :   Toggle show auxiliary lines to see the fill boundary.

Layers
:   Determines which [Layers](../../../properties/layers.xhtml) are used for boundary strokes.

    Visible:
    :   Calculates boundaries based on all visible layers.

    Active:
    :   Calculates boundaries based on the active layer.

    Layer Above:
    :   Calculates boundaries based on the layer above the active layer.

    Layer Below:
    :   Calculates boundaries based on the layer below the active layer.

    All Above:
    :   Calculates boundaries based on all layers above the active layer.

    All Below:
    :   Calculates boundaries based on all layers below the active layer.

Simplify
:   Number of simplify steps to apply to the boundary line.
    Higher values reduce the accuracy of the final filled area.

Ignore Transparent
:   When enabled, strokes with transparency does not take into account on fill boundary calculations.

    The value slider controls the threshold to consider a material transparent.

Limit to Viewport
:   When enabled, fill only visible areas in the viewport.

Auto-Remove Fill Guides
:   When enabled, after creating a fill, automatically remove the fill guide strokes.

##### Gap Closure

Gap closure lines are automatic temporarily lines that help to close gaps on the strokes.

Size
:   Control the Size of the line extension or the circumference to use to calculate the lines that will close the gaps.

Mode `S`
:   Sets the type of Gap closure method to use.

    Radius:
    :   Uses the Radius of circumference of opened nearest points to calculate a line that close the gap.

    Extend:
    :   Extends the opened strokes to close gaps.

Visual Aids
:   Toggle show closure lines helper.

Strokes Collision `D`
:   Check if extend lines collide with strokes, stopping the extension if a collision is detected.
user: Show practical ways to work with Empty Hair in a Blender add-on or script – include code.

assistant: Adds an empty high-performance curves object and automatically:

- Assigns the active object as the [Surface](../../sculpt_paint/curves_sculpting/introduction.xhtml).
- Set the surface object as the parent of the new object.
- Adds a Geometry Nodes modifier to deform the curves on the surface.
user: Describe Forward Compatibility from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Loss of Data

Forward compatibility is inherently harder to ensure, and loss of feature should always be expected
when opening a blend-file saved with a more recent version of Blender.

A warning is shown in the UI when editing a more recent blend-file.
Trying to overwrite it (with a simple ‘Save’ operation) will also show a confirmation popup,
as this could make that loss of data permanent.

### Complete Incompatibility

When Blender switches to a new major version release (e.g. from 3.x to 4.0), there can also be major
changes that will make the blend-file fully incompatible with older versions of Blender.

In such cases, older Blender will fail opening (or appending/linking from) the newer blend-file, with a
message stating which minimal version is needed to open it.

In such cases, the last LTS release of the previous release cycle will be kept compatible with the newer
file format version, and will be usable as converter between both versions.

For example, Blender 3.6 LTS can open files from Blender 4.x, and will perform the necessary conversion
such that when re-saved from 3.6, the files become compatible with all 3.x Blender versions.
user: Provide the full official documentation entry for GeometryNodeInterpolateCurves(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInterpolateCurves(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.GeometryNodeInterpolateCurves(*GeometryNode*)
:   Generate new curves on points by interpolating between existing curves

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

assistant: # NodeSocketClosure(NodeSocketStandard)

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

*class* bpy.types.NodeSocketClosure(*NodeSocketStandard*)
:   Closure socket of a node

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

The Workbench Engine is a render engine optimized for fast rendering during modeling and animation preview.
It is not intended to be a render engine that will render final images for a project.
Its primary task is to display a scene in the 3D Viewport when it is being worked on.

By default the 3D Viewport uses Workbench to shade and light objects.
Unlike other render engines such as EEVEE or Cycles, the Workbench engine does not use shader nodes.
Instead, shading settings can be tweaked in the 3D Viewport’s [Shading popover](../../editors/3dview/display/shading.html)
or the render properties when doing final renders.

Workbench supports assigning random colors to objects to make each visually distinct.
Other coloring mechanisms also exist, including; materials, Color Attributes, and textures.

Workbench also has an X-ray mode to see through objects,
along with cavity and shadow shading to help display details in objects.
Workbench supports several lighting mechanisms including studio lighting and MatCaps.

The image below is an excellent example of the Workbench engine’s capabilities
using random coloring and shadows to show the details of the model.

[image reference removed]

Workbench example.
user: How do I use Library(ID) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Library(ID)

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

*class* bpy.types.Library(*ID*)
:   External .blend file from which data is linked

    archive_libraries
    :   Archive libraries of packed IDs, generated (and owned) by this source library

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

    archive_parent_library
    :   Source library from which this archive of packed IDs was generated

        Type:
        :   [`Library`](#bpy.types.Library "bpy.types.Library"), (readonly)

    filepath
    :   Path to the library .blend file

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    is_archive
    :   This library is an ‘archive’ storage for packed linked IDs originally linked from its ‘archive parent’ library.

        Type:
        :   boolean, default False, (readonly)

    is_editable
    :   Data-blocks in this library are editable despite being linked. Used by brush assets and their dependencies.

        Type:
        :   boolean, default False, (readonly)

    needs_liboverride_resync
    :   True if this library contains library overrides that are linked in current blendfile, and that had to be recursively resynced on load (it is recommended to open and re-save that library blendfile then)

        Type:
        :   boolean, default False

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

    parent
    :   Type:
        :   [`Library`](#bpy.types.Library "bpy.types.Library"), (readonly)

    version
    :   Version of Blender the library .blend was saved with

        Type:
        :   int array of 3 items in [0, inf], default (0, 0, 0), (readonly)

    users_id
    :   ID data-blocks that use this library

        Type:
        :   tuple of [`bpy.types.ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")

        (readonly)

    reload()
    :   Reload this library and all its linked data-blocks

    *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 Make Planar Faces, preserving all code examples.

assistant: Flattens the selected faces.

Factor
:   The flattening strength for each iteration. Note that even a value of 1 may not be enough to
    get faces perfectly flat; you can increase the *Iterations* in that case.

Iterations
:   Number of times to repeat the operation.
user: Explain Duplicate Linked in complete detail according to the official Blender documentation.

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

For strips that reference an ID, for example scene strips, this will
use the same scene in the duplicated strip.
user: What is Thumb and how is it used in Blender Python scripting?

assistant: # Thumb

Similar to the [Grab](grab.xhtml) brush,
but instead only moves the geometry along the surface (using the area plane).
This is useful for grabbing surfaces with a very specific direction,
or without making too impactful changes to the overall object shape.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is reflected for each wavelength.

Scale
:   Global scale factor for the scattering radius.

Radius
:   Average distance that light scatters below the surface.
    Higher radius gives a softer appearance, as light bleeds into shadows and through the object.
    The scattering distance is specified separately for the RGB channels,
    to render materials such as skin where red light scatters deeper.
    The X, Y and Z values are mapped to the R, G and B values, respectively.

IOR Cycles Only
:   Index of refraction for *Subsurface Scattering*.

Anisotropy Cycles Only
:   Directionality of subsurface scattering. Higher anisotropy scatters deeper into the object.

Roughness Cycles Only
:   Roughness of the glossy surface surrounding the subsurface volume.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`SpaceSequenceEditor.preview_overlay`](bpy.types.SpaceSequenceEditor.html#bpy.types.SpaceSequenceEditor.preview_overlay "bpy.types.SpaceSequenceEditor.preview_overlay") |  |
user: Describe Install from a DMG from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender for macOS is distributed as disk images (dmg-files). To mount the disk image, double-click on the dmg-file.
Then drag `Blender.app` into the Applications folder.

Depending on the Security and Privacy preferences of your Mac, macOS will request your approval before opening Blender
for the first time.

To make the installation and configuration fully self-contained, set up a
[Portable Installation](../../advanced/blender_directory_layout.xhtml#portable-installation).
user: How do I use Visual Geometry as Mesh in Blender? Include parameters, examples, warnings and best practices.

assistant: Apply the visual state of all selected objects (modifiers, shape keys, hooks, etc.) to object data.
This is a way to freeze all object data into static meshes, as well as converts non-mesh types to mesh.

For details, see the [Convert](convert.xhtml#object-convert-to) mesh.
user: Provide the full official documentation entry for Set Caps, preserving all code examples.

assistant: Toggle ending cap styles of the stroke.

Rounded
:   Sets stroke start and end points to rounded (default).

Flat
:   Toggle stroke start and end points caps to flat or rounded.

Toggle Start
:   Toggle stroke start point cap to flat or rounded.

Toggle End
:   Toggle stroke end point cap to flat or rounded.

|  |  |  |
| --- | --- | --- |
| ../../../_images/grease-pencil_modes_edit_stroke-menu_cap-1.png   Stroke ending with rounded caps. | ../../../_images/grease-pencil_modes_edit_stroke-menu_cap-2.png   Stroke ending with flat caps. | ../../../_images/grease-pencil_modes_edit_stroke-menu_cap-3.png   Stroke ending with combined caps. |
user: What is Material and how is it used in Blender Python scripting?

assistant: The Viewport Display panel in the Material Properties has several settings that
are used by the Workbench Engine.

Color
:   The color when rendering the material.
    The alpha channel can be used to render the object transparent.

Metallic
:   Changes the amount of specular lighting. This is only available when
    *Specular Lighting* in the [Options](options.xhtml) is enabled.

Roughness
:   Changes the amount of roughness for specular lighting. This is only available when
    *Specular Lighting* in the [Options](options.xhtml) is enabled.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Corners
:   Four vector inputs to define the plane warping. (Z component of vector inputs is ignored.)

### 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.
user: Explain SimulationStateItem(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # SimulationStateItem(bpy_struct)

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

*class* bpy.types.SimulationStateItem(*bpy_struct*)
:   attribute_domain
    :   Attribute domain where the attribute is stored in the simulation state

        Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`

    color
    :   Color of the corresponding socket type in the node editor

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0), (readonly)

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

    socket_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The domain of an attribute refers to what type of geometry element the attribute corresponds to.
Knowing the domain of an attribute is important because it defines how it may be interpolated and
used in nodes and shading. You can use the [Spreadsheet Editor](../../editors/spreadsheet.xhtml)
to determine the domains of attributes.

- **Point** domain attributes are associated with single locations in space with a position:
  :   - Vertices of a mesh
      - Points of a point cloud
      - Curve control points
- **Edge** domain attributes are associated with the edges of a mesh.
- **Face** domain attributes are associated with the faces of a mesh.
- **Face Corner** domain attributes are associated with the corners of the faces of the mesh.
  An example is a UV map attribute.
- **Spline** domain attributes are associated with a group of connected
  curve control points.
- **Instance** domain attributes exist on the [Instances](instances.xhtml) in a geometry.
  They can be used to store different values on copies of geometry data. Instance domain attributes are
  only supported in geometry nodes.
- **Layer** domain attributes are associated with a [Grease Pencil Layer](../../grease_pencil/properties/layers.xhtml).

Attributes are automatically interpolated to other domains. For example, when the
[Position Node](geometry/read/position.xhtml) is connected to the selection input of
the [Set Material Node](geometry/material/set_material.xhtml) node, the values are interpolated
from the *Point* domain to the *Face* domain. Normally, domain conversions use simple averages
for values, but *Boolean* data type attributes have special rules for interpolation:

### Boolean Domain Interpolation

| From | To | Conversion |
| --- | --- | --- |
| Point | Edge | An edge is selected if both of its vertices were selected. |
| Point | Face | A face is selected if all of its vertices were selected too. |
| Point | Corner | Each corner’s value is simply a copy of the value at its vertex. |
| Point | Spline | A spline is selected if all of its control points were selected. |
|  |  |  |
| Edge | Point | A vertex is selected if any connected edge was selected. |
| Edge | Face | A face is selected if all of its edges are selected. |
| Edge | Corner | A corner is selected if its two adjacent edges were selected. |
|  |  |  |
| Face | Point | A vertex is selected if any of the connected faces were selected. |
| Face | Edge | An edge is selected if any connected face was selected. |
| Face | Corner | Each corner’s value is simply a copy of the value at its face. |
|  |  |  |
| Corner | Point | A vertex is selected if all connected face corners were selected and it is not a loose vertex. |
| Corner | Edge | An edge is selected if all corners on adjacent faces were selected. |
| Corner | Face | A face is selected if all of its corners were selected. |
|  |  |  |
| Spline | Point | Each point’s value is simply a copy of the corresponding value of the spline. |
user: Explain Perlin Noise 2D in complete detail according to the official Blender documentation.

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: Describe Packed Data from the Blender manual or Python API, including usage steps and snippets.

assistant: # Packed Data

Blender has the ability to encapsulate (incorporate)
various kinds of data within the blend-file that is normally saved outside of the blend-file.
For example, an image texture that is an external image file can be put “inside” the blend-file.
This allows sharing a full project as a single file,
instead of e.g. an archive containing the blend-file and all its dependencies.

You know that a data is packed when you see a little “gift box” icon displayed next to its path.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

The proverb “A good start is half the battle”, certainly applies to video editing.
Setting up your *work environment* and *project* to your needs is key to success.
In setting up your video project, you have to distinguish between:

- Work Environment related settings and activities:

  These settings apply to all of your projects and are set at “Blender level”; for example the installation
  of add-ons. In fact, they can also influence your non-video editing projects.
  Most of these settings remain more or less stable throughout your projects and should probably only set once.
- Project related settings and activities:

  These settings vary from project to project and are very specific for your project;
  for example the output media format. For each new project, you have to evaluate these settings and activities.

Of course, many settings and activities occur at both levels.
For example, automatic proxies can be enabled globally but changed on a per project or even strip basis.
The layout of the Video Editing Workspace is defined at Blender level but can be tweaked per project.
user: Explain Material in complete detail according to the official Blender documentation.

assistant: The Viewport Display panel in the Material Properties has several settings that
are used by the Workbench Engine.

Color
:   The color when rendering the material.
    The alpha channel can be used to render the object transparent.

Metallic
:   Changes the amount of specular lighting. This is only available when
    *Specular Lighting* in the [Options](options.xhtml) is enabled.

Roughness
:   Changes the amount of roughness for specular lighting. This is only available when
    *Specular Lighting* in the [Options](options.xhtml) is enabled.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

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

[image reference removed]

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

### Fixing overexposure

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

[image reference removed]

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

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

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

Finally, the Mix node blends the two together.

### Watermark Images

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

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

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

#### Encoding your Watermark in an Image

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

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

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

[image reference removed]

Embedding a watermark in an image.

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

#### Decoding an Image for your Watermark

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

[image reference removed]

Checking an image for your watermark.
user: Show practical ways to work with Connect to Output in a Blender add-on or script – include code.

assistant: Connect the output of the selected node to the final output of the node tree
(Material Output or World Output in Shader,
the final Group Output in Geometry Nodes and Compositor, Output in Texture Nodes),
or, if the node is inside a group, to the Group Output.
user: What is Add-on Extensions and how is it used in Blender Python scripting?

assistant: Add-ons should follow [semantic versioning](https://semver.org/) in spirit.

Semantic versioning was designed for software libraries with APIs, and that’s
not (typically) what add-ons are. Rather, add-ons provide user-facing
functionality, and therefore semantic versioning doesn’t strictly apply.

Nevertheless, we recommend following the *spirit* of semantic versioning with
add-ons in the following way:

- Version numbers should use the **MAJOR.MINOR.PATCH** format (e.g. 2.3.1).
- **The MAJOR number** should be incremented for changes that remove or alter
  existing functionality in such a way that users can’t just continue using the
  add-on as they previously were. Rules of thumb:

  > - If the new version doesn’t work with data created for/by the previous
  >   version, increment the MAJOR number.
  > - If the user needs to relearn anything non-trivial about the add-on to
  >   continue using it as they already were, increment the MAJOR number.
- **The MINOR number** should be incremented when introducing new functionality,
  but *without* significantly affecting existing functionality. Rule of thumb:

  > - If new functionality was introduced, but the user can simply ignore it (if
  >   desired) and continue working with the add-on as they already were,
  >   increment the MINOR number.
- **The PATCH number** should be incremented for bug fixes and small changes
  that don’t affect the add-on’s intended functionality. Rule of thumb:

  > - If the new version isn’t notably different from an end-user perspective
  >   aside from bug fixes, increment the PATCH number.

These guidelines won’t cover every possible situation, but hopefully they give a
good sense of how to approach the common cases. Extension developers should use
their best judgment when dealing with situations not covered well by these
guidelines.
user: Explain Time in complete detail according to the official Blender documentation.

assistant: The maximum number of frames for each scene is currently 1,048,574, and allows for continuous shots for durations of:

24 fps:
:   12 hours, 8 minutes.

25 fps:
:   11 hours, 39 minutes.

30 fps:
:   9 hours, 42 minutes.

60 fps:
:   4 hours, 51 minutes.
user: Provide the full official documentation entry for MovieClipUser(bpy_struct), preserving all code examples.

assistant: # MovieClipUser(bpy_struct)

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

*class* bpy.types.MovieClipUser(*bpy_struct*)
:   Parameters defining how a MovieClip data-block is used by another data-block

    frame_current
    :   Current frame number in movie or image sequence

        Type:
        :   int in [-1048574, 1048574], default 1

    proxy_render_size
    :   Display preview using full resolution or different proxy resolutions

        Type:
        :   enum in [`'PROXY_25'`, `'PROXY_50'`, `'PROXY_75'`, `'PROXY_100'`, `'FULL'`], default `'FULL'`

    use_render_undistorted
    :   Render preview using undistorted proxy

        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: What is LineStyleGeometryModifier_Sampling(LineStyleGeometryModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleGeometryModifier_Sampling(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_Sampling(*LineStyleGeometryModifier*)
:   Specify a new sampling value that determines the resolution of stroke polylines

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    sampling
    :   New sampling value to be used for subsequent modifiers

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_Sampling.type "bpy.types.LineStyleGeometryModifier_Sampling.type")
user: Show practical ways to work with Instancing in a Blender add-on or script – include code.

assistant: # Instancing

Vertices
:   This creates an instance of all children of this object on each vertex
    (for mesh objects only).

Faces
:   This creates an instance of all children of this object on each face
    (for mesh objects only).

Collection
:   This creates an instance of the collection with the transformation of the object.
    Collection instancers can be animated using actions,
    or can get a [Library Override](../../../../files/linked_libraries/library_overrides.html).
user: What is NodeTreeInterfaceSocketVectorEuler2D(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketVectorEuler2D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorEuler2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Properties Inherited Functions