PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Custom Split Normals of Meshes and how is it used in Blender Python scripting?

assistant: Blender supports the import and export of [custom normals](../../modeling/meshes/structure.xhtml#modeling-meshes-normals-custom) to
Alembic files. As a basic rule of thumb, a completely smooth mesh will be exported without normals
and thus produce the smallest Alembic file. This is reflected in the importer; an Alembic mesh
without normals is loaded as a smooth mesh.

On export, for every mesh:

- If it has *Custom Loop Normals* then the loop normals are exported.
- If one or more polygons are marked flat then loop normals are also exported.
- Otherwise, no normals are exported.

On import, when the Alembic mesh contains:

- Loop normals (`kFacevaryingScope`) are used as custom loop normals.
- Vertex normals (`kVertexScope` or `kVaryingScope`) are convert to loop normals, and handle as above.
- If there are no normals then the mesh is marked as smooth.
- Unsupported normal types (`kConstantScope`, `kUniformScope`, `kUnknownScope`) are handled as *no normals*.

When an imported mesh does not contain normals, the final look can be controlled using the
[Normal’s Shading](../../modeling/meshes/structure.xhtml#modeling-meshes-structure-normals-shading).
user: Give a detailed overview of MovieTrackingObjectTracks(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MovieTrackingObjectTracks(bpy_struct)

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

*class* bpy.types.MovieTrackingObjectTracks(*bpy_struct*)
:   Collection of movie tracking tracks

    active
    :   Active track in this tracking data object

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

    new(*\**, *name=''*, *frame=1*)
    :   create new motion track in this movie clip

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – Name of new track
            - **frame** (*int in* *[**0**,* *1048574**]**,* *(**optional**)*) – Frame, Frame number to add tracks on

        Returns:
        :   Newly created track

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

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

assistant: The *Subdivide* operator adds new control points to selected curve segments by dividing them into smaller sections.
This is useful for creating smoother transitions, preparing curves for finer adjustments,
or adding more detail for animation or modeling.

Number of Cuts
:   Specifies the number of divisions for each selected segment; each cut adds one new control point per segment.

Selected Points
:   When enabled, limits the effect to only the selected points within the stroke.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`FCurve.modifiers`](bpy.types.FCurve.html#bpy.types.FCurve.modifiers "bpy.types.FCurve.modifiers") - [`FCurveModifiers.active`](bpy.types.FCurveModifiers.html#bpy.types.FCurveModifiers.active "bpy.types.FCurveModifiers.active") - [`FCurveModifiers.new`](bpy.types.FCurveModifiers.html#bpy.types.FCurveModifiers.new "bpy.types.FCurveModifiers.new") | - [`FCurveModifiers.remove`](bpy.types.FCurveModifiers.html#bpy.types.FCurveModifiers.remove "bpy.types.FCurveModifiers.remove") - [`NlaStrip.modifiers`](bpy.types.NlaStrip.html#bpy.types.NlaStrip.modifiers "bpy.types.NlaStrip.modifiers") |
user: Give a detailed overview of Enabling Add-on: syntax, arguments, return values, common patterns.

assistant: 1. Open Blender and go to [Add-ons](../../../editors/preferences/addons.xhtml) section of the [Preferences](../../../editors/preferences/index.xhtml).
2. Search “Rigify” and check the *Enable Add-on* checkbox.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketGeometry(NodeTreeInterfaceSocket), preserving all code examples.

assistant: # NodeTreeInterfaceSocketGeometry(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.NodeTreeInterfaceSocketGeometry(*NodeTreeInterfaceSocket*)
:   Geometry socket of a node

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

assistant: [image reference removed]

Grease Pencil material slots panel.

Next to the material name there are three icons buttons that control common properties of the material:

/ (Show/Hide in Ghosts)
:   Toggle the use of the material for [Onion Skinning](../properties/onion_skinning.xhtml).

/ (Hide/Show Material)
:   Toggle whether the active material is the only one that can be edited and is visible.

/ (Lock/Unlock Material)
:   Toggle whether the active material is the only one that can be edited.

### Specials

Show All
:   Turns on the visibility of every material in the list.

Hide Others
:   Turns off the visibility of every material in the list except the active one.

Lock All
:   Locks editing of all the materials in the list.

Unlock All
:   Unlocks editing of all the materials in the list.

Lock Unselected
:   Locks all materials not used in the selected strokes.

Lock Unused
:   Locks and hides all unused materials.

Copy Material to Selected
:   Copy the active material to the selected Grease Pencil object.

Copy All Materials to Selected
:   Copy all materials to the selected Grease Pencil object.

Remove Unused Slots
:   Remove all unused materials.

### Lock & Visibility Controls

(Isolate Material)
:   Toggle whether the active material is the only one that can be edited.

(Isolate Material)
:   Toggle whether the active material is the only one that can be edited and is visible.
user: Give a detailed overview of Denoising: syntax, arguments, return values, common patterns.

assistant: Even with all the settings described above there will always end
up being some render noise no matter how many samples you use.
To fix this there is a post-processing technique to cleanup the final bit of noise.
To use this enable [Denoising](../render_settings/sampling.xhtml#render-cycles-settings-viewport-denoising)
in the *Render* tab of the Properties.

Below is an example render by
[The Pixelary](https://blog.thepixelary.com/post/160451378592/denoising-in-cycles-tested).

|  |  |
| --- | --- |
| ../../../_images/render_layers_denoising_example1.jpg   Example render before denoising. | ../../../_images/render_layers_denoising_example2.jpg   Example render after denoising. |
user: Show practical ways to work with N in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**N-gon**](glossary/index.xhtml#term-N-gon) - [**NDOF**](glossary/index.xhtml#term-NDOF) - [Nodes](interface/controls/nodes/index.xhtml#index-0)   - [Closure](interface/controls/nodes/types/utilities/closure/closure.xhtml#index-0)   - [Combine Bundle Node](interface/controls/nodes/types/utilities/bundles/combine_bundle.xhtml#index-0)   - [Compositing Nodes](compositing/introduction.xhtml#index-0)   - [Evaluate Closure](interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml#index-0)   - [Geometry Nodes](modeling/geometry_nodes/index.xhtml#index-0)   - [Join Bundle Node](interface/controls/nodes/types/utilities/bundles/join_bundle.xhtml#index-0)   - [Separate Bundle](interface/controls/nodes/types/utilities/bundles/separate_bundle.xhtml#index-0)   - [Shader Nodes](render/shader_nodes/introduction.xhtml#index-0)   - [Texture Nodes](editors/texture_node/introduction.xhtml#index-1) | - [**Non-manifold**](glossary/index.xhtml#term-Non-manifold) - [**Non-uniform Rational Basis Spline**](glossary/index.xhtml#term-Non-uniform-Rational-Basis-Spline) - [**Nonlinear Animation**](glossary/index.xhtml#term-Nonlinear-Animation) - [**Normal**](glossary/index.xhtml#term-Normal) - [**Normal Mapping**](glossary/index.xhtml#term-Normal-Mapping) - [**NURBS**](glossary/index.xhtml#term-NURBS) |
user: How do I use Extensions Listing HTML in Blender? Include parameters, examples, warnings and best practices.

assistant: The `server-generate` command can optionally create a simple website using the `--html` argument.

```
blender --command extension server-generate --repo-dir=/path/to/packages --html
```

This creates an `index.html` file ready to use, listing extensions which
can be dropped into Blender for installation.

### Download Links

In order to support drag and drop for installing from a remote repository,
there are a few optional ways to prepare the URLs.

The only strict requirement is that the download URL must end in `.zip`.

You can pass different arguments to the URL to give more clues to Blender about what to do with the dropped URL.

> repository:
> :   Link to the JSON file to be used to install the repository in Blender.
>     Supports relative URLs.
>
> platforms:
> :   Comma-separated list of supported platforms.
>     If omitted, the extension will be available in all operating systems.
>
> blender_version_min:
> :   Minimum supported Blender version, e.g., `4.2.0`.
>
> blender_version_max:
> :   Blender version that the extension does not support, earlier versions are supported.

With the exception of the `repository`, all the other parameters can be extracted from the extensions manifest.
Those arguments are to be encoded as part of the URL.

Expected format:
:   `{URL}.zip?repository={repository}&blender_version_min={version_min}&blender_max={version_max_exclusive}&platforms={platform1,platform2}`

Example from self-hosted repository:
:   `http://my-site.com/my-addon.zip?repository=.%2Findex.json&blender_version_min=4.2.0&platforms=windows-x64`

Example from the Extensions Platform:
:   `https://extensions.blender.org/download/sha256:57a6a5f39fa2cc834dc086a27b7b2e572c12fd14f8377fb8bd1c7022df3d7ccb/add-on-amaranth-v1.0.23.zip?repository=%2Fapi%2Fv1%2Fextensions%2F&blender_version_min=4.2.0&platforms=linux-x64%2Cmacos-x64`
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Keyed Physics settings.

Loops
:   Sets the number of times the entire *Keys* list is repeated. Disabled if *Use Timing* is enabled.

Use Timing
:   Enabling this option allows you to specify the timing for each key independently,
    using the *Time* and *Duration* options.
    By default, the *Use Timing* option is deactivated, and the particles will pass through all keys
    for a time equal to its lifetime. A shorter lifetime means faster movement.
    The lifetime will be split equally between the keys,
    this may lead to varying particle speeds between the targets.
user: Give a detailed overview of Arm Rig Example: syntax, arguments, return values, common patterns.

assistant: This arm uses two bones to overcome the twist problem for the forearm.
IK locking is used to stop the forearm from bending,
but the forearm can still be twisted manually by pressing `R` `Y` `Y` in *Pose Mode*,
or by using other constraints.

[image reference removed]

[IK Arm Example](https://archive.blender.org/wiki/2015/index.php/File:IK_Arm_Example.blend).

Note that, if a *Pole Target* is used, IK locking will not work on the root bone.
user: How do I use Expand Active Face Set in Blender? Include parameters, examples, warnings and best practices.

assistant: Expands an existing face set with a geodesic falloff.
This operator uses the same internal operator as [Expand](#bpy-ops-sculpt-expand)
meaning all the hotkeys and functionality works the same as that tool.

### Usage

Resizing Face Sets
:   Resize a Face Set along the surface distances.
    It is an alternative to [Grow/Shrink Face Sets](face_sets.html#bpy-ops-sculpt-face-set-edit)
    which follows the topology instead of geodesic distances.

Joining Face Sets
:   When holding `Ctrl` the expansion will instead snap to other Face Sets.
    This is a fast way of joining multiple face sets into one.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Color
:   Scattering coefficients per color channel.

Density
:   The density of the scatter effect.

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

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

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

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

Diameter Mie
:   Diameter of the scattering particles in µm.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: Below are some common curves you can use to achieve desired effects.

[image reference removed]

From left to right: 1. Lighten shadows 2. Negative 3. Decrease contrast 4. Posterize.

### Color Correction using Curves

[image reference removed]

Color correction with curves.

In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.

The documentation for the [Mix Color Node](../../../compositing/types/color/mix_color.xhtml) has an additional
example about fixing overexposure.

### Color Correction using Black/White Levels

[image reference removed]

Color correction with Black/White Levels.

Manually adjusting the RGB curves for color correction can be difficult.
Another option for color correction is to use the Black and White Levels instead,
which really might be their main purpose.

In this example,
the White Level is set to the color of a bright spot of the sand in the background,
and the Black Level to the color in the center of the fish’s eye.
To do this efficiently it is best to bring up the Image Editor showing the original input image.
You can then use the levels’ color picker to easily choose
the appropriate colors from the input image, zooming into pixel level if necessary.
The result can be fine-tuned with the R, G, and B curves like in the previous example.

The curve for C is used to compensate for the increased contrast that is a side effect of
setting Black and White Levels.

### Effects

[image reference removed]

Changing colors by inverting the red channel.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Geometry Attribute constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The target object to retrieve geometry from.
    The supported geometry types are Mesh, Curve, Point Cloud, and Instance.

Offset with Target Transform
:   Apply the target object’s world transform on top of the attribute’s transform.

Attribute Name
:   Name of the sampled attribute.
    The default attribute name is position.

Data Type
:   Data type of the sampled attribute.
    The type will determine which components will be used for transforming the constraint object.

    Vector:
    :   Vector data type, affects the location.

    Quaternion:
    :   Quaternion data type, affects the rotation.

    4x4 Matrix:
    :   4x4 Matrix data type, affects the entire transform.
        Location, Rotation, and Scale components can be toggled separately, but will remove matrix shearing.

Domain
:   Domain of the sampled attribute.

    Point:
    :   Point domain from a Mesh, Curve, or Point Cloud.

    Edge:
    :   Edge domain from a Mesh.

    Face:
    :   Face domain from a Mesh.

    Face Corner:
    :   Face Corner domain from a Mesh.

    Spline:
    :   Spline domain from a Curve.

    Instance:
    :   Instance domain from an Instance.

Sample Index
:   Index of the geometry element to sample the attribute.
    Index values are clamped to what is present on the target geometry.

Mix Mode
:   Specify how the copied and existing transformations are combined.

    Replace:
    :   Replace the original transformation with the transform from the attribute.

    Before Original (Full):
    :   Apply copied transformation before original, using simple matrix multiplication as if
        the constraint target is a parent in Full Inherit Scale mode.
        Will create shear when combining rotation and non-uniform scale.

    Before Original (Split Channels):
    :   Apply copied transformation before original, handling location, rotation and scale
        separately, similar to a sequence of three Copy constraints.

    After Original Full:
    :   Apply copied transformation after original, using simple matrix multiplication as if
        the constraint target is a child in Full Inherit Scale mode.
        Will create shear when combining rotation and non-uniform scale.

    After Original (Split Channels):
    :   Apply copied transformation after original, handling location, rotation and scale
        separately, similar to a sequence of three Copy constraints.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image/Color
:   Standard color input.

Hue
:   The hue rotation offset, from 0 (-180°) to 1 (+180°). Note that
    0 and 1 have the same result.

Saturation
:   A value of 0 removes color from the image, making it black-and-white.
    A value greater than 1.0 increases saturation.

Value
:   The value shift. 0 makes the color black, 1 keeps it the same, and higher
    values make it brighter.

Factor
:   The amount of influence the node exerts on the image.
user: What is Drivers and how is it used in Blender Python scripting?

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Linux, graphics drivers are usually installed as a package by your Linux distribution. Installing the latest
drivers is typically done by upgrading packages or the distribution as a whole. Some distributions provide multiple
packages for multiple drivers versions, giving you the choice to install newer versions.

For NVIDIA, there are open source (Nouveau) and closed source (by NVIDIA) graphics drivers. Blender functions best
with the closed source drivers as they are more optimized and complete. Linux graphics drivers can be downloaded from
NVIDIA’s website, however in most cases the ones from your Linux distribution are fine and make things easier.
Manually downloading drivers is mostly useful to get the very latest version, for example for a GPU that was only
recently released.

Note, drivers before 550 do not support Vulkan!

[NVIDIA Website](https://www.nvidia.com/Download/index.aspx)
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The UV Editor is used for editing UV maps, which describe how a 2D image should be mapped
onto a 3D object.

[image reference removed]

UV Editor with a UV map and a test grid texture.

Image textures are typically needed when the desired look is hard to achieve with procedural textures,
or if the texture is not uniform. For example, a car would only have scratches in a few places where they make sense,
not in random places all over its body.

Blender offers a number of projections (Box, Sphere…) that automatically apply a 2D image to a 3D object,
but these tend to only work for simple meshes. For more complex ones, you need to create a UV map instead.
This is a flat area where each face of the 3D object is laid out on the 2D image, specifying which part of the
image it should be textured with. This gives you complete control over the mapping process.

The name “UV” refers to the axes of the map: U for horizontal, V for vertical. These letters were chosen to
avoid confusion with “X” and “Y”, which refer to axes in 3D space instead.
user: Give a detailed overview of Simulation Nodes: syntax, arguments, return values, common patterns.

assistant: # Simulation Nodes

Through the use of [Simulation Zones](../modeling/geometry_nodes/simulation/simulation_zone.xhtml),
[Geometry Nodes](../modeling/geometry_nodes/index.xhtml) can be used to create custom physic simulations through nodes.
Simulation zones allow the result of one frame to influence the next one.
That way even a set of simple rules can lead to complex results, with the passing of time.
The most common type of them is physics simulation, with specific solvers for physical phenomena.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Vertices
:   Number of vertices in the top and/or bottom circle of the cone.
    No geometry is generated if the number is below three.

Side Segments
:   Number of vertically stacked face loops that make up the cone’s sides.
    Increasing this will add horizontal cuts.
    No geometry is generated if the number is below one.

Fill Segments
:   Number of concentric rings in the top and/or bottom.
    No geometry is generated if the number is below one.

Radius Top
:   The radius of the cone’s top circle.
    If this is zero, the circle is reduced to a single vertex.

Radius Bottom
:   Same as *Radius Top* but for the bottom circle.

Depth
:   Height of the generated cone.
user: Give a detailed overview of Geometry Nodes Modifier: syntax, arguments, return values, common patterns.

assistant: # Geometry Nodes Modifier

The *Geometry Nodes* modifier creates a modifier with a node group which defines its functionality.

[image reference removed]

A new Geometry Nodes modifier with a new node group.

This modifier is supported by mesh, curve, text, and volume objects.
user: Explain SpreadsheetTable(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # SpreadsheetTable(bpy_struct)

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

*class* bpy.types.SpreadsheetTable(*bpy_struct*)
:   Persistent data associated with a table

    columns
    :   Columns within the table

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

    id
    :   Data used to identify the table

        Type:
        :   [`SpreadsheetTableID`](bpy.types.SpreadsheetTableID.html#bpy.types.SpreadsheetTableID "bpy.types.SpreadsheetTableID"), (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: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Blur Effect samples (Samples: 8).

|  |  |  |  |
| --- | --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_blur_factor-0.png   Original Model. | ../../_images/grease-pencil_visual-effects_blur_factor-10.png   Factor: 10, 10. | ../../_images/grease-pencil_visual-effects_blur_factor-50.png   Factor: 50, 50. | ../../_images/grease-pencil_visual-effects_blur_factor-100.png   Factor: 100, 100. |
user: How do I use Linked Duplicate in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates copies of the selected strips, reusing any actions they reference.
Editing the keyframes in a copied strip therefore also affects the original
(and vice versa). Blender warns you about this by highlighting the other strip in red.

[image reference removed]

Linked duplicated strip being edited.
user: Explain Face Sets in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Face sets are used to group your mesh into differently colored faces,
which can then be quickly hidden or shown like mentioned above.
They can also be used for fast mask creation via the [Mask Expand](../editing/expand.xhtml#bpy-ops-sculpt-expand).
[Face Set Expand](../editing/expand.xhtml#face-set-expand) is also useful for creating, editing and joining face sets.

More options can be found in the `Alt`-`W` pie menu.

[image reference removed]

Otherwise Face Sets can be created/edited with the
[Draw Face Sets](../brushes/draw_facesets.xhtml) brush,
[Mask Gesture Tools](../tools/mask_tools.xhtml).
They can also be edited with the
[Edit Face Set](../tools/edit_face_set.xhtml) tool.

Internally, face sets are stored using the `sculpt_face_set` [Attributes](../../../modeling/geometry_nodes/attributes_reference.xhtml).
user: Provide the full official documentation entry for Track, preserving all code examples.

assistant: Track
:   See [Track Motion](../editing/track.xhtml#bpy-ops-clip-track-markers).

Clear
:   See [Before](../editing/track.xhtml#bpy-ops-clip-clear-track-path).

Refine
:   See [Refine](../editing/track.xhtml#bpy-ops-clip-refine-markers).

Merge
:   Join Tracks
    :   See [Join Tracks](../editing/track.xhtml#bpy-ops-clip-join-tracks).
user: Describe PreferencesView(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: lt 45

    view_frame_keyframes
    :   Keyframes around cursor that we zoom around

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

    view_frame_seconds
    :   Seconds around cursor that we zoom around

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

    view_frame_type
    :   How zooming to frame focuses around current frame

        Type:
        :   enum in [`'KEEP_RANGE'`, `'SECONDS'`, `'KEYFRAMES'`], default `'KEEP_RANGE'`

    weight_color_range
    :   Color range used for weight visualization in weight painting mode

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Snap to Symmetry

The Snap to Symmetry tool lets you snap a mesh vertices to their mirrored neighbors.

Useful when dealing with meshes which are mostly symmetrical,
but have vertices which have been moved enough that Blender
does not detect them as mirrored (when X Mirror option is enabled for example).

This can be caused by accident when editing without X Mirror enabled. Sometimes models
imported from other applications are asymmetrical enough that mirror fails too.

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

Threshold
:   Specify the search radius to use when finding matching vertices.

Factor
:   Support for blending mirrored locations from one side to the other (0.5 is an equal mix of both).

Center
:   Snap vertices along the center axis to zero.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_snap-symmetry_before.png   Before Snap to Symmetry. | ../../../../_images/modeling_meshes_editing_mesh_snap-symmetry_after.png   After Snap to Symmetry. |
user: Explain Troubleshooting Graphics Hardware in complete detail according to the official Blender documentation.

assistant: # Troubleshooting Graphics Hardware

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Provide the full official documentation entry for Editing Masks, preserving all code examples.

assistant: # Editing Masks

The tools and panels available to edit masks are the same in both editors.
Editing of mask splines happens in a way similar to editing Bézier curves or paths in GIMP or other curve editors.
user: Show practical ways to work with NodeTreeInterfaceSocketVectorDirection4D(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketVectorDirection4D(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.NodeTreeInterfaceSocketVectorDirection4D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 4 items in [-inf, inf], default (0.0, 0.0, 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: Explain Usage in complete detail according to the official Blender documentation.

assistant: ### General

*UV Project* is great for making spotlights more diverse, and also for creating decals to break up repetition.

Usually, an [Image Texture node](../../../render/shader_nodes/textures/image.html) mapped to the UV map
that the modifier targets is added to the object’s material.
user: How do I use Channels Region in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Channels region.

This region is found on the left side of time-based editors like
the [Dope Sheet Editor](../../dope_sheet/introduction.html) and the Graph Editor.
It shows a tree of items (objects, bones…) and their animated properties,
with the latter also being called “channels.” Each channel has an associated F-curve
describing how its value changes over time.

The rows are color-coded as follows:

- Dark blue: scenes, objects
- Light blue: [actions](../../../animation/actions.html), [shape keys](../../../animation/shape_keys/index.html) etc.
- Green: channel groups
- Gray: channels

Search `Ctrl`-`F`
:   Lets you filter the channels by typing a part of their name. Click the Invert button to instead
    show channels that *don’t* include the search text.

### Channels

The headers contain the following toggle buttons:

/ Pin
:   Keep the row and its children visible even when selecting a different object.

/ Hide
:   Hides the keyframes and curve associated with the channel.

/ Modifiers
:   Deactivates the modifiers of the curve.

/ Mute
:   Deactivates the curve, making the animation behave as though it doesn’t exist.

/ Lock `Tab`
:   Prevent the curve from being edited.

### Selection

- Select single header: click `LMB`
- Add/Remove single header to/from selection: click `Ctrl`-`LMB`
- Select range: click `Shift`-`LMB`
- Select All: `A`
- Deselect All: press `Alt`-`A` or double-tap `A`
- Box Select: drag `LMB`
- Box Add: drag `Shift`-`LMB`
- Box Remove: drag `Ctrl`-`LMB`
- Select all keyframes in the channel: double-click `LMB` on its header.

### Editing

- Rename (anything but a channel): double-click `LMB`
- Delete selected: `X` or `Delete`
- Lock selected: `Tab`

#### Sliders

[image reference removed]

The Action editor showing sliders.

If you enable View ‣ Show Sliders, the region will show a
value slider next to each channel. Changing such a slider will change the value
of the curve at the current frame, creating a keyframe if one doesn’t already exist.
user: Provide the full official documentation entry for Chroma Vectorscope, preserving all code examples.

assistant: This scope visualizes the color distribution of the image. Each point has:

- An angle indicating its hue.
- A distance-from-center indicating its saturation.
- A brightness indicating how many pixels in the video frame have the
  above hue and saturation.

|  |  |
| --- | --- |
| ../../../../_images/video-editing_preview_display-mode_example.jpg   Example image. | ../../../../_images/video-editing_preview_display-mode_vectorscope.png   Corresponding Chroma Vectorscope. |
user: How do I use Working Offline in Blender? Include parameters, examples, warnings and best practices.

assistant: For security or other reasons, workstation may not have internet access.

By default Blender does not access the internet, however this can be
enabled in the System preferences with the
[Online Access](../editors/preferences/system.html#bpy-types-preferencessystem-use-online-access) option.

Working offline can be enforced by running with the `--offline-mode`
[command line argument](command_line/arguments.html#command-line-args-network-options). Users
will then be unable to enable online access in the preferences.
user: Show practical ways to work with USD Primvar data types in a Blender add-on or script – include code.

assistant: Blender supports a subset of the
[USD basic data types](https://openusd.org/release/api/_usd__page__datatypes.html#Usd_Basic_Datatypes) for import
and export.

Only the types natively supported by Blender’s
[attribute system](../../modeling/geometry_nodes/attributes_reference.xhtml) will be processed.

| Blender type | USD type | Notes |
| --- | --- | --- |
| Boolean | bool |  |
| 8-Bit Integer | uchar | The USD unsigned 8-bit value will be cast to a signed value for import. The signed value will be cast to unsigned for export. |
| Integer | int | A 32-bit signed integer value. |
| Float | float | A 32-bit, single-precision, floating point value. |
| Vector | float3 | 3D vector with 32-bit floating-point values. |
| 2D Vector | float2/texCoord2f | 2D vector with 32-bit floating-point values. |
| Color | color4f | RGBA color with 32-bit floating-point values. As a special case, when encountering a Primvar or attribute for USD’s `displayColor`, it will be read or written as `color3f` data with an Alpha component of 1.0. |
| Byte Color | color4f | USD does not provide a byte color equivalent. The byte values will be converted to float and exported as a color4f. |
| Quaternion | quatf | Floating point [Quaternion](../../glossary/index.xhtml#term-Quaternion) rotation. |
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Curve tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.html#grease-pencil-draw-common-options) for more information.

### Creating Curves

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can tweak the curve using two cyan Bézier like manipulators.
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can hold `Shift` to use only one manipulator to tweak the curve (like the Arc tool),
use `Alt` to create the arc from a center point.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel` will increase
or decrease the amount of points in the final curve.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_curve_example-01.png>   click and dragging the start point. | <../../../../_images/grease-pencil_modes_draw_tools_curve_example-02.png>   Tweaking curve with the manipulators. | <../../../../_images/grease-pencil_modes_draw_tools_curve_example-03.png>   The curve after confirming. |

### Extruding

Before confirming you can use `E` to extrude the end point of the curve
to generate multiple connected curves.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_curve_extrude-01.png>   End point extruding. | <../../../../_images/grease-pencil_modes_draw_tools_curve_extrude-02.png>   Tweaking the last curve with the manipulators. | <../../../../_images/grease-pencil_modes_draw_tools_curve_extrude-03.png>   The connected curves after confirming. |
user: Give a detailed overview of View: syntax, arguments, return values, common patterns.

assistant: ### Backdrop

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

Backdrop panel.

The backdrop is the output of a Viewer node in the background of the Compositor.
For example, when `Shift`-`Ctrl`-`LMB` on an Image node, it displays a preview of the image,
or on a Mix node, will show the result of the mixing.
You can toggle the backdrop by clicking the checkbox in the *Backdrop* panel title
or by clicking on the *Backdrop* button in the header.

Channels
:   The color channels to display of the backdrop image.

Zoom `Alt`-`V` `V`
:   Sets the size of the backdrop image.

Offset
:   Change the screen space position of the backdrop.

Move `Alt`-`MMB`
:   Changes the position of the backdrop.

Fit
:   Scales the backdrop to fit the size of the Compositor.

Reset Backdrop
:   Sets back to the default values of Zoom to 1 and Offset to 0.
user: What is Transform Modal Map and how is it used in Blender Python scripting?

assistant: # Transform Modal Map

During a transformation, some hotkeys can change the behavior of the operation.

You can check editing the keys of these modal modifiers in
Blender Preferences ‣ Keymap ‣ Transform Modal Map
(at the bottom of the keymap).
user: Show practical ways to work with Workflow in a Blender add-on or script – include code.

assistant: The process for working with standard particles is:

1. Create the mesh which will emit the particles.
2. Create one or more Particle Systems to emit from the mesh. Many times, multiple
   particle systems interact or merge with each other to achieve the overall desired effect.
3. Tailor each Particle System’s settings to achieve the desired effect.
4. Animate the base mesh and other particle meshes involved in the scene.
5. Define and shape the path and flow of the particles.
6. For [Hair](hair/index.html) particle systems: Sculpt the emitter’s flow
   (cut the hair to length and comb it for example).
7. Make final render and do physics simulation(s), and tweak as needed.

### Creating a Particle System

[image reference removed]

Adding a particle system.

To add a new particle system to an object, go to the *Particles* tab of the Properties
editor and click the  button. An object can have many Particle Systems.

Each particle system has separate settings attached to it.
These settings can be shared among different particle systems, so one does not have to copy
every setting manually and can use the same effect on multiple objects.

#### Types of Particle Systems

[image reference removed]

Particle System Types.

After you have created a particle system,
the Properties fills with many panels and buttons.
But do not panic! There are two different types of particle systems,
and you can change between these two with the *Type* selector:
Emitter and Hair.

The settings in the *Particle System* tab are partially different for each system type.
user: Provide the full official documentation entry for Navigating, preserving all code examples.

assistant: Entering a Directory `Return`
:   Double-click a directory to enter it.

Parent Directory `P`
:   Takes you up one level of directory.

### File Drop

You can also drag and drop a file or directory from your file manager into the Blender File Browser.
This will navigate to the item and select it.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: # Options

[image reference removed]

Paint options.

The weight paint options change the overall brush behavior.

Auto Normalize
:   Ensures that all deforming vertex groups add up to one while painting.
    When this option is turned off, then all weights of a vertex can have any value between 0 and 1.
    However, when vertex groups are used as deform groups for character animation
    then Blender always interprets the weight values relative to each other.
    That is, Blender always does a normalization over all deform bones.
    Hence in practice it is not necessary to maintain a strict normalization and
    further normalizing weights should not affect animation at all.

    This option works most intuitively when used to maintain normalization while
    painting on top of weights that are already normalized with another tool.

Lock-Relative
:   Displays bone-deforming groups as if all locked deform groups were deleted,
    and the remaining ones were re-normalized.
    This is intended for use when balancing weights within a group of bones while all other bones are locked.
    With this option you can also temporarily view non-normalized weights as if they were normalized,
    without actually changing the values.

Multi-Paint
:   Paint on all selected vertex groups simultaneously, in a way that preserves their relative influence.
    This can be useful when tweaking weights in an area that is affected by more than three bones at once,
    e.g. certain areas on a character’s face.

    This option is only useful in the *Armature* tab, where you can select multiple vertex groups
    by selecting multiple pose bones. Once at least two vertex groups are selected,
    viewport colors and paint logic switch to Multi-Paint mode,
    using the sum of the selected groups’ weights if *Auto Normalize* is enabled,
    and the average otherwise. Any paint operations aimed at this collective weight are applied to
    individual vertex group weights in such way that their ratio stays the same.

    Since the ratio is undefined if all weights are zero, Multi-Paint cannot operate on
    vertices that do not have any weight assigned to the relevant vertex groups.
    For this reason it also does not allow reducing the weight all the way to zero.
    When used with *X Mirror*, it only guarantees completely a symmetrical result
    if weights are initially symmetrical.

Restrict
:   This option limits the influence of painting to vertices (even with weight 0)
    belonging to the selected vertex group.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: The inputs of the node are dynamic. Some inputs are only available for certain operations.
For instance, the *Addend* input is only available for the *Multiply Add* operator.

Value
:   Input Value. Trigonometric functions read this value as radians.

Addend
:   Input Addend.

Base
:   Input Base.

Exponent
:   Input Exponent.

Epsilon
:   Input Epsilon.

Distance
:   Input Distance.

Min
:   Input Minimum.

Max
:   Input Maximum.

Increment
:   Input Increment.

Scale
:   Input Scale.

Degrees
:   Input Degrees.

Radians
:   Input Radians.