PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: ### Transform

Correct Face Attributes
:   Adjust geometry attributes like [UVs](../uv/index.html)
    and [Color Attributes](../../../sculpt_paint/vertex_paint/index.html) while transforming.

Keep Connected
:   Merge attributes connected to the same vertex while using *Correct Face Attributes*.

#### Mirror

The *Mirror* options enable symmetric transformations
of mesh elements (vertices, edges, or faces) along the selected axis.
When an element is transformed, its exact mirrored counterpart (in local space),
if present, is transformed correspondingly to maintain symmetry.

For the *Mirror* tool to function correctly, mirrored vertices must be precisely aligned with their counterparts.
If vertices are not accurately positioned at their mirror locations,
the *Mirror Axis* will not recognize them as mirrored.
For meshes with visual symmetry but differing topology,
enabling [Topology Mirror](#bpy-types-mesh-use-mirror-topology) can address this limitation.

#### Topology Mirror

*Topology Mirror* determines mirrored vertices by analyzing their relationships with other vertices in the mesh,
rather than relying solely on vertex positions.
By evaluating the overall topology, this feature allows non-symmetrical vertices to be treated as mirrored.

*Topology Mirror* requires at least one *Mirror Axis* to be enabled.

Example

This example demonstrates how to use *Topology Mirror* effectively:

1. Open a new Blender scene. Delete the default cube and add a Monkey object in the 3D Viewport.
2. Press `Tab` to switch to *Edit Mode*.
3. Disable all *Mirror* axes and move one of the Monkey object’s vertices slightly.
4. Enable the *X Axis Mirror* option but leave *Topology Mirror* disabled.
   Move the same vertex again. The *X Axis Mirror* will not affect the mirrored vertices, as they are not perfectly
   aligned.
5. Enable *Topology Mirror* and move the same vertex once more.
   The *X Axis Mirror* will now mirror the other vertex, even though they are not perfectly positioned.

#### Auto Merge

When enabled, as soon as a vertex moves closer to another one
than the *Threshold* setting, they are automatically merged.
This option affects interactive operations only
(tweaks made in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel are considered interactive too).
If the exact spot where a vertex is moved contains more than one vertex,
then the merge will be performed between the moved vertex and one of those.

Split Edges & Faces
:   Detects the intersection of each transformed edge, creating a new vertex in place
    and sectioning the edge and the face if any.

Threshold
:   Defines the maximum distance between vertices that are merged.

### UVs

Live Unwrap
:   Automatically recalculates the UV unwrapping every time an edge has its seam property changed.
    Note, this is different than the [Live Unwrap](../uv/editing.html#bpy-types-spaceuveditor-use-live-unwrap)
    option in the UV Editor.
user: Show practical ways to work with Library Linking in a Blender add-on or script – include code.

assistant: When linking a rig into another file, you generally want to create a collection that includes
the generated rig and the character mesh. You do not need to include the meta-rig or the widget
object collection. You then link in the collection and run
[Make Library Override](../../../files/linked_libraries/library_overrides.xhtml#bpy-ops-object-make-override-library).

The `rig_ui_template.py` text data-block responsible for the rig UI
will be automatically linked along with the rig, you don’t need to link it separately.
However, the script will not run until you run it manually from the Text editor or save and restart Blender.
user: Give a detailed overview of Fix to Camera: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Also known as “bake to camera”, this operator will ensure selected objects/bones
remain static (relative to the camera) on unkeyed frames.

This is done by generating new keys. These keys will be of [type
‘Generated’](../../../animation/keyframes/introduction.html#keyframe-type) so that it remains clear which keys were manually
created, and which were generated. This way the tool can be re-run to
re-generate the keys.

1. Ensure your animation is keyed using constant interpolation. If this is not
   the case yet, bake your animation (at least the transform channels). This
   tool does _not_ work with the [“Stepped” F-Curve modifier](../../graph_editor/fcurves/modifiers.html#bpy-types-fmodifierstepped)
2. Choose which of the Location/Rotation/Scale channels you want to fix to the
   camera. When unsure, make sure they are all checked.
3. Press the “Fix to Camera” button.

To undo the effect of the “Fix to Camera” operator, click on the trash bin
button. That will remove all the generated keys in either the scene range or the
frame range.

The tool operates on the scene frame range, or on the preview range if that is
active. Keys outside that range are ignored, both when fixing to the camera and
when removing generated keys.

### Limitations

Pasting a transform adjusts the Object/Bone’s location, rotation, and
scale. This means that when copying a skewed transform, this skew is lost.

If there are constraints on the Object/Bone, the resulting visual transformation
may not be the same as the pasted one. To give a concrete example: if you have a
constraint that adds a rotation, it will always add that rotation on top of the pasted transform.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Domain
:   The type of geometry to extract and split.
    This is also the domain on which the *Selection* and *Group ID* fields are evaluated.

    Point:
    :   Points, spline control points, and vertices.

    Edge:
    :   Mesh edges.

    Face:
    :   Mesh faces.

    Spline:
    :   Curve splines.

    Instance:
    :   Top-level instances. Realized instances are ignored.

    Layer:
    :   Grease Pencil layers.
user: Give a detailed overview of AnnotationStroke(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # AnnotationStroke(bpy_struct)

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

*class* bpy.types.AnnotationStroke(*bpy_struct*)
:   Freehand curve defining part of a sketch

    points
    :   Stroke data points

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`AnnotationStrokePoint`](bpy.types.AnnotationStrokePoint.html#bpy.types.AnnotationStrokePoint "bpy.types.AnnotationStrokePoint"), (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 CacheFileLayer(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CacheFileLayer(bpy_struct)

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

*class* bpy.types.CacheFileLayer(*bpy_struct*)
:   Layer of the cache, used to load or override data from the first the first layer

    filepath
    :   Path to the archive

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

    hide_layer
    :   Do not load data from this layer

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Adding Nodes in a Blender add-on or script – include code.

assistant: Nodes are added via the *Add* menu in the editor’s header or using a keyboard shortcut.

Nodes can also be added by dragging a connection from an existing node’s input or output socket
and dropping the connection above an empty space instead of connecting to another socket.
This action will open a search menu with a list of compatible nodes
and their sockets that can be added and connected to the existing node.
Confirming the menu selection will add the node which can then be moved and placed.
user: Give a detailed overview of basic.pivot: syntax, arguments, return values, common patterns.

assistant: Single-bone rig type that creates a ‘custom pivot’ control for rotating and scaling its child sub-rigs.

This type of control transforms its children when rotated or scaled, while moving it
merely changes the pivot point used by rotation or scaling.

Master Control
:   When enabled an extra parent control bone with a box widget is created to allow moving the rig.
    It is also required by all other options besides *Deform Bone*.

Widget Type
:   Allows selecting one of the predefined widgets to generate for the master control instead of the default cube.

Switchable Parent
:   Generates a mechanism for switching the effective parent of the rig based on the value of a custom property.

Register Parent
:   Registers the rig as a potential parent scope for its child sub-rigs’ parent switches.

    Tags
    :   Specifies additional comma-separated tag keywords for the registered parent scope.
        They can be used by other rigs to filter parent choices, or for selecting the default parent.

        Some of the existing tags that are useful here:

        `injected` (special)
        :   The parent scope will be made available for all children of the *parent* sub-rig,
            rather than just this rig’s children.

        `held_object`
        :   A control for the object held in the character’s hand. Preferred by finger IK.

            The `injected,held_object` combination is perfect for such a control.

Pivot Control
:   Disabling this avoids generating the actual custom pivot control, effectively turning this rig type
    into a version of [basic.super_copy](#basic-super-copy) with parent switching support and a different widget.

Deform Bone
:   When enabled a deform bone will be created.
user: Show practical ways to work with Geometry in a Blender add-on or script – include code.

assistant: # Geometry

In this tab you control the geometry of your strokes.
It contains only the option to add modifiers.

As they always completely apply to the strokes’ geometry (like object modifiers do).
They take the resulting two-dimensional strokes from the Freestyle line set and
displace or deform them in various ways.

As with other modifier stacks in Blender, they are applied from top to bottom.

[image reference removed]

Line Style: Geometry.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: You can do just about anything with images using nodes.

Raw footage from a foreground actor in front of a blue screen,
or a rendered object doing something, can be layered on top of a background.
Composite both together, and you have composited footage.

You can change the mood of an image:

- To make an image ‘feel’ colder, a blue tinge is added.
- To convey a flashback or memory, the image may be softened.
- To convey hatred and frustration, add a red tinge or enhance the red.
- A startling event may be sharpened and contrast-enhanced.
- To convey a happy feeling add yellow (equal parts red and green, no blue).
- Dust and airborne dirt are often added as a cloud texture over the image to give a little more realism.
user: Provide the full official documentation entry for Delete, preserving all code examples.

assistant: Deletes selected vertices, edges, or faces. This operation can also be limited to:

Vertices
:   Delete all vertices in current selection, removing any faces or edges they are connected to.

Edges
:   Deletes any edges in the current selection. Removes any faces that the edge shares with it.

Faces
:   Removes any faces in current selection.

Only Edges & Faces
:   Limits the operation to only selected edges and adjacent faces.

Only Faces
:   Removes faces, but edges within the face selection are retained.
user: Show practical ways to work with Sound in a Blender add-on or script – include code.

assistant: Working with sound is documented further at [Sound Strip](../../../../video_editing/edit/montage/strips/sound.xhtml#bpy-types-soundstrip).

Volume
:   Adjusts the perceived loudness or intensity of the sound.

    When this property is animated, the volume is drawn as an overlay on the strip.
    The overlay will look like a dark section that follows the animation curve.
    This can be hidden by disabling the [F-Curves](../display.xhtml#bpy-types-sequencertimelineoverlay-show-fcurves).
    The value is also reflected in the waveform.

Offset
:   Offset of the sound from the beginning of the strip, expressed in seconds.

Mono
:   Mixdown all audio channels into a single channel.

[image reference removed]

Pan
:   Used to pan the audio between speakers in multichannel audio.
    Only mono sources can be panned; if the source file is not mono, enable *Mono* to mix the channels together.

    This value basically represents the angle at
    which it’s played if you multiply the value by 90 degrees.

    For stereo, output panning works from left (-1) to center (0) and finally right (1).

    To address rear speakers, you can pan to those with higher values,
    where -2 is back left and 2 is back right.

Preserve Pitch
:   When enabled, this option maintains the original pitch of the
    audio even when the playback speed of the strip is changed.
    When disabled, adjusting the playback speed of a sound strip also
    alters its pitch (for example, slowing down lowers the pitch, and speeding up raises it).

    This option is useful when synchronizing audio to video edits or animations
    that require timing adjustments without affecting tone or musical key.

Display Waveform
:   Display an approximate waveform of the sound file inside of the Sound strip.
    The waveform reflects strip volume and its animation using [keyframes](../../../../animation/keyframes/introduction.xhtml).

    Clipping audio, i.e. values over 100% amplitude, will be shown in red.

    This option is only visible if the [Waveforms overlay](../display.xhtml#bpy-types-sequencertimelineoverlay) is set to *Strip*.
user: How do I use FunctionNodeRotateEuler(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeRotateEuler(FunctionNode)

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

*class* bpy.types.FunctionNodeRotateEuler(*FunctionNode*)
:   Apply a secondary Euler rotation to a given Euler rotation

    rotation_type
    :   Method used to describe the rotation

        - `AXIS_ANGLE`
          Axis Angle – Rotate around an axis by an angle.
        - `EULER`
          Euler – Rotate around the X, Y, and Z axes.

        Type:
        :   enum in [`'AXIS_ANGLE'`, `'EULER'`], default `'EULER'`

    space
    :   Base orientation for rotation

        - `OBJECT`
          Object – Rotate the input rotation in the local space of the object.
        - `LOCAL`
          Local – Rotate the input rotation in its local space.

        Type:
        :   enum in [`'OBJECT'`, `'LOCAL'`], default `'OBJECT'`

    *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 Convert to Mesh Plane in a Blender add-on or script – include code.

assistant: Converts the selected [image empty](../../../modeling/empties.xhtml#bpy-types-object-empty-image) to a textured mesh plane.

For a description of the options see [Mesh Plane](../../../modeling/meshes/import_images_as_planes.xhtml).
user: What is Volume to Mesh Node and how is it used in Blender Python scripting?

assistant: # Volume to Mesh Node

[image reference removed]

The *Volume to Mesh* node generates a mesh on the “surface” of a volume.
The surface is defined by a threshold value.
All voxels with a larger value than the threshold are considered to be inside.
user: What is ThemeRegionsChannels(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ThemeRegionsChannels(bpy_struct)

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

*class* bpy.types.ThemeRegionsChannels(*bpy_struct*)
:   back
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text_selected
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Edge Split Modifier and how is it used in Blender Python scripting?

assistant: # Edge Split Modifier

The *Edge Split* modifier splits, duplicates edges within a mesh,
breaking ‘links’ between faces around those split edges.

The edges to split can be determined from the edge angle (i.e. angle between faces forming that edge),
and/or edges marked as sharp.

Splitting an edge affects vertex normal generation at that edge, making the edge appear sharp.
It can also be used for manual control of the smoothing process,
where the user defines which edges should appear smooth or sharp
(see [Mesh Smoothing](../../meshes/editing/mesh/shading.xhtml#modeling-meshes-editing-normals-shading) for other ways to do this).
If desired, both modes can be active at once.
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.
user: Explain To Sphere in complete detail according to the official Blender documentation.

assistant: # To Sphere

The *To Sphere* transformation will give the selection spherical qualities.
The Fig. [Monkey with increasing sphericity.](#fig-mesh-deform-to-sphere-monkey) below shows the results of applying
the *To Sphere* transformation to the monkey mesh.

[image reference removed]

Monkey with increasing sphericity.

The sequence above shows a monkey mesh with
a 0, 0.25 (25%), 0.5 (50%) and 1 (100%) To Sphere transform applied.
user: Explain Delete in complete detail according to the official Blender documentation.

assistant: Removes the selected *Vertices* (control points) or *Segments* (lines) from the surface. In both cases,
the selection must consist of one or more complete rows or columns of the surface grid.

Vertices
:   Deletes the selected control points. The resulting gap is bridged with new grid lines so that the surface
    stays contiguous.

Segments
:   Deletes the lines and control points that lie between the outermost selected control points.
    The resulting gap is not bridged.

Dissolve Vertices
:   This feature only works for [Curves](../../curves/index.xhtml).

[image reference removed]

Before and after deleting a row of control points.
user: Explain Categories in complete detail according to the official Blender documentation.

assistant: There are four categories of built-in modifiers:

Edit
:   Similar to the *Deform* modifiers (see below),
    however, they usually do not directly affect the geometry of the object,
    but some other data, such as vertex groups.

Generate
:   Constructive/destructive modifiers that will affect the whole [Topology](../../glossary/index.xhtml#term-Topology) of the mesh.
    They can change the general appearance of the object, or add new geometry to it…

Deform
:   Unlike *Generate* ones above, these modifiers only change the shape of an object, without altering its topology.

Simulate
:   Represent [physics simulations](../../physics/index.xhtml). In most cases, they are automatically added to
    the modifiers stack whenever a *Particle System* or *Physics* simulation is enabled. Their only role is to define
    the position in the modifier stack from which is taken the base data for the simulation they represent.
    As such, they typically have no properties, and are controlled by settings exposed in
    separate sections of the [Properties Editor](../../editors/properties_editor.xhtml).

You will also notice a category called “Hair”,
this category comes from a bundled [Asset Library](../../glossary/index.xhtml#term-Asset-Library) that is distributed with Blender.
See [Hair Nodes](../geometry_nodes/hair/index.xhtml) for more information.

Users can make their own categories by making geometry node groups [assets](../../glossary/index.xhtml#term-Asset)
and assigning them to a [Asset Catalog](../../glossary/index.xhtml#term-Asset-Catalog). This catalog name will be the category name.
If a user creates a catalog with the same name as one of the built-in categories
the node group will be added to the bottom of the corresponding menu.

Node Groups that are non-assets or that do not belong to a category will be available in the “Unassigned” sub-menu.
user: Give a detailed overview of Extensions Tags: syntax, arguments, return values, common patterns.

assistant: # Extensions Tags

A different set of tags is available for the different extensions types.
This is the list of the tags currently supported by the [Blender Extensions Platform](https://extensions.blender.org/):
user: How do I use Extra in Blender? Include parameters, examples, warnings and best practices.

assistant: Parents Particles
:   Render also parent particles if child particles are used.
    Children have a lot of different deformation options,
    so the straight parents would stand between their curly children.
    So by default *Parents* are not rendered if you activate *Children*.
    See [Children](children.xhtml).

Unborn
:   Render particles before they are born.

Dead
:   Render particles after they have died.
    This is very useful if particles die in a collision *Die on hit*, so you can cover objects with particles.
user: What is IntAttribute(Attribute) and how is it used in Blender Python scripting?

assistant: # IntAttribute(Attribute)

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

*class* bpy.types.IntAttribute(*Attribute*)
:   Geometry attribute that stores integer values

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`IntAttributeValue`](bpy.types.IntAttributeValue.html#bpy.types.IntAttributeValue "bpy.types.IntAttributeValue"), (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: How do I use Noise in Blender? Include parameters, examples, warnings and best practices.

assistant: # Noise

The *Noise* modifier uses a pseudo-random number generator to variably distribute the property along the stroke.

Amplitude
:   The maximum value of the noise. A higher amplitude means a less transparent (more solid) stroke.

Period
:   The period of the noise. This means how quickly the property value can change.
    A higher value means a more smoothly changing color along the stroke.

Seed
:   Seed used by the pseudo-random number generator.

Asymmetric Thickness only
:   Allows the thickness to be distributed unevenly at every point.
    Internally, the stroke is represented as a backbone with a thickness to the right and left side.
    All other thickness shaders make sure that the left and right thickness values are equal.
    For the Noise shader however, a meaningful (and good-looking) result
    can be created by assigning different values to either side of the backbone.

[image reference removed]

Effect generated with a noise thickness modifier using asymmetric thickness.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

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

Roughness
:   Controls the amount of color that is reflected back to the camera,
    higher values reflect more color and can give a dusty appearance, while lower values look fuzzy and darker.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: Give a detailed overview of Refraction BSDF: syntax, arguments, return values, common patterns.

assistant: # Refraction BSDF

[image reference removed]

The *Refraction* BSDF
is used to add glossy refraction with sharp or microfacet distribution,
used for materials that transmit light. For best results this node should be considered as
a building block and not be used on its own,
but rather mixed with a glossy node using a Fresnel factor.
Otherwise it will give quite dark results at the edges for glossy refraction.
user: Provide the full official documentation entry for How Rigify Works, preserving all code examples.

assistant: Rigify Meta-Rigs are split in multiple Sub-Rigs
:   A meta-rig is an assembly of bone chains. A bone chain is identified by the *Connected* attribute.
    Bone chains can be further connected together by parenting them without using the *Connected* attribute
    (i.e. using the *Keep Offset* option while parenting).

A custom attribute is set on the first bone of the sub-rig chain
:   Each first bone of a bone chain has a custom attribute on it which is a Rigify custom property
    that identifies the sub-rig type. At rig generation time Rigify will determine which controls and
    deform bones will be created processing the meta-rig from the first bone to the last of each chain.

    [image reference removed]

    Human meta-rig split by samples.

New meta-rigs are created assembling sub-rigs samples
:   Since a meta-rig is just a collection of sub-rigs,
    new meta-rigs can be built assembling sub-rigs in different ways.
    This way an infinite number of meta-rigs can be built from the same rigging blocks.

    [image reference removed]

    Cat meta-rig built by samples.

All the mechanics, deformation bones and widget are created on a single click
:   The meta-rig contains more information than the visualized bones.
    In fact at generation time Rigify will identify each sub-rig type and depending on
    the selected options will create all the sophisticated controls, switches, and
    deforming bones with a single click.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`Scene.sequence_editor`](bpy.types.Scene.html#bpy.types.Scene.sequence_editor "bpy.types.Scene.sequence_editor") | - [`Scene.sequence_editor_create`](bpy.types.Scene.html#bpy.types.Scene.sequence_editor_create "bpy.types.Scene.sequence_editor_create") |
user: Explain Texture in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Typical modifier Texture options.

Those options allow to use any kind of image (including parametric ones) to control the modifier’s effect.
Most of the time, only the value (grayscale) of the texture is used,
but in some cases (like with some modes of the [Displace modifier](deform/displace.xhtml#bpy-types-displacemodifier)),
the whole RGB color components might be exploited.

Texture
:   The [texture data-block](../../render/materials/legacy_textures/introduction.xhtml) to use.

Texture Coordinates
:   The texture’s coordinates to get each vertex’ value:

    UV
    :   Take texture coordinates from face UV coordinates.

        UV Map
        :   The [UV Map](../../glossary/index.xhtml#term-UV-Map) from which to take texture coordinates. If the object has no
            UV coordinates, it falls back to the *Local* coordinate system. If this field is blank,
            but there is a UV map available (e.g. just after adding the first UV map to the mesh),
            the currently active UV map will be used.

    Object
    :   Take the texture coordinates from another object’s coordinate system.

        Object
        :   The object from which to take texture coordinates.
            Moving the object will therefore alter the coordinates of the texture mapping.

            If this field is blank, it falls back to the *Local* coordinate system.

    Global
    :   Take the texture coordinates from the global coordinate system.

    Local
    :   Take the texture coordinates from the object’s local coordinate system.

Use Channel
:   Which channel to use as value source
    (only available with a few modifiers currently, others follow the *Intensity* behavior,
    unless otherwise specified).

    Intensity
    :   The average of the RGB channels (if RGB(1.0, 0.0, 0.0) value is 0.33).

    Red/Green/Blue/Alpha
    :   One of the color channels’ values.

    Hue
    :   The hue from the HSV color model
        (i.e; the color in the standard wheel, e.g. blue has a higher hue value than yellow).

    Saturation
    :   The saturation from the HSV color model (e.g. the value for pure red is 1.0, for gray is 0.0).

    Value
    :   The value from the HSV color model.
user: What is Light Linking and how is it used in Blender Python scripting?

assistant: # Light Linking

With light linking, you can set up lights that only illuminate specific objects in the scene.
Shadow linking additionally gives control over which objects block the light (cast shadows).

This adds more artistic control by breaking the laws of physics. For example, you could
have a rim light that *only* illuminates a character in a scene (light linking) and is
not blocked by any objects in the scene (shadow linking).
user: What is Onion Skinning and how is it used in Blender Python scripting?

assistant: # Onion Skinning

Onion Skinning show ghosts of the keyframes before and after the current frame allowing animators
to make decisions in the animation sequence.

The main switch to show/hide Onion Skinning is in the [Viewport Overlays](../../editors/3dview/display/overlays.html#dview-overlay-grease-pencil),
but Grease Pencil Onion Skinning is per-layer and the visibility can be toggle in the layer list.
See [2D Layers](layers.html) for more information.

[image reference removed]

Onion Skinning panel.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

UI for a Curve Guide force field.

Free
:   Fraction of particle life time, that is not used for the curve.

Falloff Power
:   This setting governs the strength of the guide between *Min Distance* and *Max Distance*.
    A falloff of 1 means a linear progression.

Additive
:   If you use *Additive*, the speed of the particles is also evaluated depending on the falloff.

Weights
:   Use Curve weights to influence the particle influence along the curve.

Clumping Amount
:   The particles come together at the end of the curve (1) or they drift apart (-1).

Shape
:   Defines the form in which the particles come together.
    +0.99: the particles meet at the end of the curve.
    0: linear progression along the curve. -0.99: the particles meet at the beginning of the curve.

Min Distance
:   The distance from the curve, up to where the force field is effective with full strength.
    If you have a falloff of 0, this parameter will have no effect,
    because the field is effective with full strength up to *Max Distance* (or the infinity).
    *Min Distance* is shown with a circle at the endpoints of the curve in the 3D Viewport.

Max Distance
:   The maximum influence radius. Shown by an additional circle around the curve object.

### Kink

Type
:   Changes the shape that the particles can take.

    None:

    Braid:

    Curl:
    :   The radius of the influence depends on the distance of the curve to the emitter.

    Radial:
    :   A three-dimensional, standing wave.

    Roll:
    :   A one-dimensional, standing wave.

    Rotation:

    Wave:
    :   A two-dimensional, standing wave.

    It is not so easy to describe the resulting shapes, so have a look at the example below.

    [image reference removed]

    Kink options of a curve guide. From left to right: Radial, Wave, Braid, Roll.
    [Animation](https://vimeo.com/1866538).

Axis
:   Which axis to use for the offset.

Frequency
:   The frequency of the offset.

Shape
:   Adjust the offset to the beginning/end.

Amplitude
:   The Amplitude of the offset.
user: What is Linestyle Geometry Modifier Type Items and how is it used in Blender Python scripting?

assistant: # Linestyle Geometry Modifier Type Items

2D_OFFSET:
:   2D Offset.

2D_TRANSFORM:
:   2D Transform.

BACKBONE_STRETCHER:
:   Backbone Stretcher.

BEZIER_CURVE:
:   Bézier Curve.

BLUEPRINT:
:   Blueprint.

GUIDING_LINES:
:   Guiding Lines.

PERLIN_NOISE_1D:
:   Perlin Noise 1D.

PERLIN_NOISE_2D:
:   Perlin Noise 2D.

POLYGONIZATION:
:   Polygonization.

SAMPLING:
:   Sampling.

SIMPLIFICATION:
:   Simplification.

SINUS_DISPLACEMENT:
:   Sinus Displacement.

SPATIAL_NOISE:
:   Spatial Noise.

TIP_REMOVER:
:   Tip Remover.
user: What is Volumes and how is it used in Blender Python scripting?

assistant: # Volumes

Volume rendering is used to render various effects that cannot be represented by hard surfaces alone.

- Smoke, fire or clouds are set up using a volume object or fluid simulation,
  with only a volume shader.
- Meshes can also be used to create such shapes by removing the default surface shader
  and using a volume shader with the mesh shape defining the volume bounds
  and textures defining the volume density.
- Mist is created with a volume shader for the world,
  or with a large mesh object encompassing the scene.
- Absorption in glass is simulated by combining a glass surface shader with refraction
  and a volume absorption shader for the interior of the object.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Image to put in place of the plane track, and thus, override that area in the movie clip.

### Motion Blur

Specify whether to use blur caused by motion of the plane track or not.

Samples
:   Set the number of samples to take for each frame.
    The higher this number, the smoother the blur effect,
    but the longer the render, as each virtual intermediate frame has to be rendered.

Shutter
:   Time (in frames) the shutter is open.
    If you are rendering at 24 fps, and the Shutter is set to 0.5,
    the time in between frames is 41.67 ms,
    so the shutter is open for half that, 20.83 ms.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The Clip View is the main part of the Movie Clip editor;
almost all motion tracking tools are concentrated within the Clip View.

It should be mentioned that the camera solver consists of three quite separate steps:

1. 2D tracking of footage.
2. Camera intrinsics (focal length, distortion coefficients) specification/estimation/calibration.
3. Solving camera, scene orientation, and scene reconstruction.
user: Give a detailed overview of Baking: syntax, arguments, return values, common patterns.

assistant: The simulation is automatically cached during playback.
The valid cache can be seen as a strong yellow line in the timeline editor.
This allows for animators to quickly inspect all the previous frames of a simulation.

[image reference removed]

Cached frames in the Timeline.

When the result is ready to be sent to a render-farm, it can be baked to disk.
This allows for the simulation to be rendered in a non-sequential order.

[image reference removed]

Simulation and Physics, Geometry Nodes user interface.

Calculate to Frame
:   Calculate simulations in geometry nodes modifiers from the start to current frame.

Bake
:   Bake simulations in geometry nodes modifiers.
    In order to bake the simulation, the blend-file must be saved to your computer.
    The location the file is saved determines where the baked data is also saved.
    The directory the baked data is saved to can be changed per modifier in the
    [Internal Dependencies](../modeling/modifiers/geometry_nodes.html#bpy-types-nodesmodifier-bake-directory).

    Delete Cached Simulation
    :   Delete cached/baked simulations in geometry nodes modifiers

Cache
:   For the cases where the current frame is the only one relevant,
    users can opt-out of caching the results to save memory.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Cube object was duplicated.

The object `Cube` was duplicated, using `Shift`-`D`. Both these cubes have
separate meshes with unique names: `Cube` and `Cube.001`.

- The original left cube is being edited, the duplicated right cube remains unchanged.
  The mesh data has been copied, not linked.
- Likewise, if one cube is edited in Object Mode, the other cube remains
  unchanged. The new object’s transform properties or data-block is a copy, not linked.
- When the cube was duplicated, it inherited the material of the original cube.
  The material properties were linked, not copied.

See above if you want separate copies of the data-blocks normally linked.
user: Give a detailed overview of skin.basic_chain: syntax, arguments, return values, common patterns.

assistant: This is the basic chain rig, which bridges controls with B-Bones but does not add
any automation to the controls themselves.

When controls are merely moved, the chains behave as if using standard
automatic handles, but rotating and optionally scaling the controls will adjust the result.

B-Bone Segments
:   Specifies the number of segments to use. Setting this to 1 disables
    all advanced behavior and merely bridges the points with a Stretch To bone.

Merge Parent Rotation and Scale
:   This can be enabled to let the chain respond to rotation and scale induced by parents of
    controls owned by other chains that this chain’s control merged into.

Use Handle Scale
:   Enables using control scale to drive scale and/or easing of the B-Bone.

Connect With Mirror
:   Specifies whether the ends of the chain should smoothly connect when merging controls
    with its `.T`/`.B` `.L`/`.R` symmetry counterpart. The relevant option must be enabled
    on both chains to work.

Connect Matching Ends
:   Specifies whether the end of the chain should connect to the opposite end of a different chain
    when merging controls. Thus forming a continuous smooth chain in the same direction.
    The relevant options must be enabled on both chains.

Sharpen Corner
:   Specifies whether the rig should generate a mechanism to form a sharp corner at
    the relevant connected end, depending on the angle formed by adjacent control locations.
    When the control angle becomes sharper than the specified value, ease starts reducing from 1 to 0.

Orientation
:   Specifies that the controls should be oriented the same as the selected bone, rather than being
    aligned to the chain.

    Copy To Selected
    :   Copy to selected rigs that have the same option. Thus allowing to indiscriminately selecting bones
        without assigning unnecessary values.

Chain Priority
:   Allows overriding the heuristic used to select the primary owner when merging controls.
user: Show practical ways to work with ShaderFxRim(ShaderFx) in a Blender add-on or script – include code.

assistant: # ShaderFxRim(ShaderFx)

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

*class* bpy.types.ShaderFxRim(*ShaderFx*)
:   Rim effect

    blur
    :   Number of pixels for blurring rim (set to 0 to disable)

        Type:
        :   int array of 2 items in [0, 32767], default (0, 0)

    mask_color
    :   Color that must be kept

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    mode
    :   Blend mode

        Type:
        :   enum in [`'NORMAL'`, `'OVERLAY'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`], default `'NORMAL'`

    offset
    :   Offset of the rim

        Type:
        :   int array of 2 items in [-32768, 32767], default (0, 0)

    rim_color
    :   Color used for Rim

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    samples
    :   Number of Blur Samples (zero, disable blur)

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

    *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 Convex Hull, preserving all code examples.

assistant: # Convex Hull

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

[image reference removed]

Input mesh, point cloud, and Convex Hull result.

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

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

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

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

Max Face Angle, Max Shape Angle, Compare
:   See [Triangles to Quads](../face/triangles_quads.xhtml#bpy-ops-mesh-tris-convert-to-quads).
user: What is Menu Switch Node and how is it used in Blender Python scripting?

assistant: # Menu Switch Node

[image reference removed]

The *Menu Switch* node outputs one of its inputs based on a selected menu item.
Only the active input is evaluated, allowing efficient switching between multiple options.

The available menu entries are defined by the user. Menu items can be
added and removed, as well as renamed and reordered in the editor side
bar. Renaming a menu entry keeps existing links of the matching input
socket.

The menu can be used in node groups and the nodes modifier UI.
Connecting the menu input with a *Group Input* node will expose the menu
as a group input. A menu socket in a node group, reroute node, or other
pass-through nodes needs to be connected to a *Menu Switch* node in
order to work. An unconnected menu socket will show an empty menu by
default.

Connecting multiple *Menu Switch* nodes to the same output
socket creates a conflict (even when the menu entries are the same).
To avoid this a menu switch can be wrapped in a node group. Multiple
node groups of the same type can be connected to the same menu, since
they contain the same menu switch node.

|  |  |
| --- | --- |
| ../../../_images/node-types_GeometryNodeMenuSwitch_conflict.webp   Conflict caused by connecting different menus. | ../../../_images/node-types_GeometryNodeMenuSwitch_group_wrapper.webp   Same node group can be connected without conflict. |