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

assistant: It might not be possible to track a given feature over the whole duration of the shot.
The feature might be blurred or obscured; it might even move out of sight entirely,
due to deliberate camera movement.
In such a situation, we need *another tracked feature* to take on its role, and we need some *overlap time*
to get a smooth transition without visible jump.

[image reference removed]

Irregular Tracks.

The stabilizer is able to deal with gaps and partial coverage within the given tracks.
However, the basic assumption is that each track covers a single,
fixed reference point whenever there is any usable/enabled data.
Thus, you must not “reuse” a given track to follow several different points,
rather you should disable and thus end one track, when tracking this feature is no longer feasible.
You may include “gaps”, when a tracking point is temporarily disabled or unavailable,
but you should start a new track for each distinct new feature to be tracked.

Each track contributes to the overall result by the degree controlled through its *Stab Weight* parameter.
It is evaluated on a per-frame basis, which enables us to control the influence of a track by *animating* this
*Stab Weight*. You may imagine the overall working of the stabilizer as if each tracking point “drags” the image
through a flexible spring: When you turn down the *Stab Weight* of a tracking point,
you decrease the amount of “drag”
it creates. Sometimes the contribution of different tracks has to work partially counter each other.
This effect might be used to cancel out spurious movement, e.g. as caused by perspective.
But when, in such a situation, one of the involved tracks suddenly goes away,
a jump in image position or rotation might be the result. Thus, whenever we notice
a jump at the very frame where some partially covered track starts or ends, we need to soften the transition.
We do so by animating the *Stab Weight* gradually down, so that it reaches zero at the boundary point.
In a similar vein, when we plan a “handover” between several partially covered tracks, we define a *cross-fade* over
the duration where the tracks overlap, again by animating the *Stab Weight* parameters accordingly.
But even with such cross-fade smoothing, some residual movement might remain,
which then needs to be corrected with the *Expected Position*
or *Expected rotation* parameters. It is crucial to avoid “overshooting” movements in such a situation –
always strive at setting the animation keyframes onto precisely the same frame number
for all the tracks and parameters involved.
user: Describe File and Paths from the Blender manual or Python API, including usage steps and snippets.

assistant: At Preferences ‣ File Paths you can set options such as what *Image Editor* (GIMP, Krita…) and
*Animation Player* to use.

The [Temporary Directory](../../advanced/blender_directory_layout.xhtml#temp-dir) sets where to store files such as temporary renders and auto-saves.

See [File Preferences](../../editors/preferences/file_paths.xhtml) for details.
user: How do I use With Empty Groups in Blender? Include parameters, examples, warnings and best practices.

assistant: When parenting it will create empty [vertex groups](../../../modeling/meshes/properties/vertex_groups/index.xhtml)
on the child objects (if they do not already exist) for and named after each deforming bone in the armature.
The newly created vertex groups will be empty. This means they will not have any weights assigned.
Vertex groups will only be created for bones which are setup as deforming
(Properties ‣ Bone ‣ Deform Panel).

You can then manually select the vertices and assign them to a particular vertex group of your
choosing to have bones in the armature influence them.

Choose this option if you have already created (and weighted) all the vertex groups the mesh requires.

### Example

For example, if you have an armature which consists of three bones named “BoneA”,
“BoneB” and “BoneC” and cube mesh called “Cube”. If you parent the cube to
the armature, the cube will get three new vertex groups created on it called “BoneA”,
“BoneB” and “BoneC”. Notice that each vertex group is empty.

[image reference removed]

Cube in Edit Mode using Armature Deform with empty groups.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: The image below shows a typical shader node tree that maps a floral texture image along strokes.
The UV Along Stroke input node retrieves UV maps defined by Freestyle along generated strokes, and
passes them to the Vector input channel of the Image Texture node.
A texture image is selected in the Image Texture node,
and its color is inputted to the Alpha channel of the Line Style Output node.
Since the Alpha Factor is set to one, the texture image replaces the base alpha transparency of the active line style
(shown in the Freestyle Line Style panel).
On the other hand, the Mix blend mode is selected in the Line Style Output node with the Color Factor set to zero,
so that the gradient line color specified in the active line style is applied along strokes.

[image reference removed]

Example of Line Style Nodes
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Blender_272_textured_strokes_in_cycles.blend)).

It is noted that the texture image `FS_floral_brush.png`
shown in the screen capture is an example of Freestyle brush images with tips.
Specifically, the upper half of the image is used as a seamless horizontal tile of the stroke body.
Whereas the parts in the lower half are tips (stroke caps) at both ends of the stroke.
user: What is Sound Strips and how is it used in Blender Python scripting?

assistant: These strips control when a [Speaker Objects](../../render/output/audio/speaker.html) starts to playback the audio.
Playback continues the length of audio file and does not take into account the length of the sound strip.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

The Vertex Weight Edit modifier panel.

Vertex Group
:   The vertex group to affect.

Default Weight
:   The default weight to assign to all vertices not in the given vertex group.

Group Add
:   Adds vertices with a final weight over *Add Threshold* to the vertex group.

Group Remove
:   Removes vertices with a final weight below *Remove Threshold* from the vertex group.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Falloff

Falloff Type
:   Type of mapping.

    Linear
    :   No mapping.

    Custom Curve
    :   Allows you to manually define the mapping using a curve.

    Sharp, Smooth, Root and Sphere
    :   These are classical mapping functions, from spikiest to roundest.

    Random
    :   Uses a random value for each vertex.

    Median Step
    :   Creates binary weights (0.0 or 1.0), with 0.5 as cutting value.

Invert
:   Inverts the falloff.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers.

Global Influence
:   The overall influence of the modifier
    (0.0 will leave the vertex group’s weights untouched, 1.0 is standard influence).

In addition, a per-vertex fine control of the effect is possible using either a vertex group or a texture
(both are mutually exclusive). The per-vertex values from those will be multiplied with the *Global Influence*.

See [common masking options](../common_options.xhtml#modifiers-common-options-masking) for a complete reference.
user: How do I use P in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [**Panel**](glossary/index.xhtml#term-Panel) - [**Parent**](glossary/index.xhtml#term-Parent) - [**Parenting**](glossary/index.xhtml#term-Parenting) - [**Particle System**](glossary/index.xhtml#term-Particle-System) - [**Phong**](glossary/index.xhtml#term-Phong) - [**Pivot Point**](glossary/index.xhtml#term-Pivot-Point) - [**Pixel**](glossary/index.xhtml#term-Pixel) - [**Pixels Per Inch**](glossary/index.xhtml#term-Pixels-Per-Inch) - [**Point Cloud**](glossary/index.xhtml#term-Point-Cloud) - [**Pole**](glossary/index.xhtml#term-Pole) | - [**Pose Bone**](glossary/index.xhtml#term-Pose-Bone) - [**Pose Mode**](glossary/index.xhtml#term-Pose-Mode) - [**Posing**](glossary/index.xhtml#term-Posing) - [**PPI**](glossary/index.xhtml#term-PPI) - [**Premultiplied Alpha**](glossary/index.xhtml#term-Premultiplied-Alpha) - [**Primaries**](glossary/index.xhtml#term-Primaries) - [**Primitive**](glossary/index.xhtml#term-Primitive) - [**Procedural Texture**](glossary/index.xhtml#term-Procedural-Texture) - [**Projection**](glossary/index.xhtml#term-Projection) - [**Proxy**](glossary/index.xhtml#term-Proxy) |
user: Give a detailed overview of EEVEE only Nodes: syntax, arguments, return values, common patterns.

assistant: These nodes are only available if EEVEE is the active render engine. These nodes will not work in Cycles.

### Shader to RGB

EEVEE supports the conversion of BSDF outputs into color inputs to make a wide variety of custom shading.
This is supported using the [Shader to RGB](../../shader_nodes/color/shader_to_rgb.xhtml) node.
This node evaluates the lighting of the BSDFs connected to it just like a *Blended* material and inherits
its limitation.

### Specular BSDF

This [node](../../shader_nodes/shader/specular_bsdf.xhtml) implements the specular workflow
found in other render engines.
user: Describe Selecting Curve Elements from the Blender manual or Python API, including usage steps and snippets.

assistant: # Selecting Curve Elements

Hair curves, while similar to regular curves are a bit different and have their own selection tools.
Many of these match their regular curve tools but are implemented differently
All hair curve selection operators are documented below for completeness.

These selection operators work in both Sculpt and Edit modes.
user: Explain Using Blender From The Command Line in complete detail according to the official Blender documentation.

assistant: # Using Blender From The Command Line

The *Console Window*, also called a *Terminal*, is an operating system text window that displays
messages about Blender’s operations, status, and internal errors.

When Blender is manually started from a terminal,
Blender output is shown in the *Console Window* it is started from.

Use Cases:

- For [rendering animation](render.html#command-line-render).
- For automation and batch processing which require launching Blender
  with different [arguments](arguments.html#command-line-args).
- For Python development, to see the output of the `print()` function.
- If Blender exits unexpectedly, the messages may indicate the cause or error.
- When troubleshooting, to see the output of `--debug` messages.

See: [Launching from the Command Line](launch/index.html#command-line-launch-index)
for specific instructions on launching Blender from the command line.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Phase
:   Volume scattering phase function.

    Henyey-Greenstein:
    :   Simple and widely used phase function, useful for approximating scattering in biological tissues.

    Fournier-Forand:
    :   Cycles Only
        Suitable for modeling the scattering of light in underwater environments.

    Draine:
    :   Cycles Only
        Suitable for modeling the scattering of interstellar dust.

    Rayleigh:
    :   Cycles Only
        Describes the scattering by particles with a size smaller than the wavelength of light,
        such as the scattering of sunlight in earth’s atmosphere.

    Mie:
    :   Cycles Only
        Describes the scattering by particles with a size larger than the wavelength of light, such as cloud and fog.
user: Describe Other Considerations from the Blender manual or Python API, including usage steps and snippets.

assistant: In axis-angle and quaternion modes we can lock rotations in interactive modes in a per component basis,
instead of doing it by axis. To do so we can activate this locking ability using the lock buttons next to
the corresponding *Rotation* transform buttons.

Regarding rotation animations, all keyframes must be defined in the same rotation mode,
which must be the selected rotation mode for the object throughout the entire animation.
user: What is Bpy.Types.Fileassetselectparams and how is it used in Blender Python scripting?

assistant: ge On this page FileAssetSelectParams(FileSelectParams) FileAssetSelectParams FileAssetSelectParams.asset_library_reference FileAssetSelectParams.catalog_id FileAssetSelectParams.filter_asset_id FileAssetSelectParams.import_method FileAssetSelectParams.instance_collections_on_append FileAssetSelectParams.instance_collections_on_link FileAssetSelectParams.bl_rna_get_subclass() FileAssetSelectParams.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Audio in a Blender add-on or script – include code.

assistant: Options to control global audio settings.
To control how sounds is played back from within Blender, see the audio settings
in the [Preferences](../../editors/preferences/system.xhtml#prefs-system-sound).

Volume
:   Volume for the scene.

Distance Model
:   Changes how the sound attenuation is calculated based on the distance.
    Most physically correct is the *Inverse* model,
    but it’s also possible to choose a linear and an exponential falloff.
    The clamped modes limit the volume to be lower than 100% (1.0),
    that means if the distance is smaller than the reference distance, the volume is always 100%.
    For an exact description of each option
    see the [OpenAL documentation](https://www.openal.org/documentation/).

Doppler Speed
:   Speed of the sound for the Doppler effect calculations.
    The typical value is 343.3 m/s in air, in water for example this value is around 1560 m/s.

Doppler Factor
:   Controls how strong the Doppler effect is.
    You can exaggerate or attenuate the change of pitch, but physically correct is a factor of 1.0.

Update Animation Cache
:   Updates the audio animation cache. This is useful if you start noticing artifact in the audio.
user: Show practical ways to work with Sensor Noise Node in a Blender add-on or script – include code.

assistant: # Sensor Noise Node

[image reference removed]

The *Sensor Noise* node simulates the random noise patterns produced by digital camera sensors.
This can be used to match real footage, add realism to rendered images, or stylistically mimic
the imperfections of digital imaging systems.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Type
:   *Soft* or *Hard*, changes contrast and sharpness.

Color
:   Grayscale:
    :   The standard noise, gives a floating-point intensity value.

    Color:
    :   The noise gives an RGB value.

Size
:   The dimension of the Noise table.

Depth
:   The depth of the *Clouds* calculation.
    A higher number results in a long calculation time, but also in finer details.

Nabla
:   Size of the derivative offset used for calculating surface normals.
    Smaller values give more precision, larger values are smoother/faster.
    This is mostly relevant when the texture is used in displacement or bump channels.
user: Show practical ways to work with Known Limitations in a Blender add-on or script – include code.

assistant: ### UV Overlap

In general overlapping UVs are not supported (as with texture baking).

However, this is only a problem when a single brush stroke paints onto multiple faces
that share a texture.

### Perspective View & Faces Behind the View

When painting onto a face which is partially behind the view (in perspective mode),
the face cannot be painted on.
To avoid this, zoom out or use an orthographic viewport.

### Perspective View & Low Poly

When painting onto a face in perspective mode onto a low-poly object with
normals pointing away from the view, painting may fail; to workaround disable
the [Normal Falloff](../brush/falloff.html#bpy-types-imagepaint-use-normal-falloff) option in the stroke settings.

Typically this happens when painting onto the side of a cube
(see [Blender bug #34665](https://projects.blender.org/blender/blender/issues/34665)).
user: Give a detailed overview of Snap: syntax, arguments, return values, common patterns.

assistant: Apart from using the snapping operators in this menu, you can also turn on
[snapping](../introduction.xhtml#bpy-types-toolsettings-use-snap-anim) in the header.

Selection to Current Frame
:   Set the selected keyframes’ time to the current frame.

Selection to Cursor Value
:   Set the selected keyframes’ value to that of the [2D Cursor](../introduction.xhtml#graph-editor-2d-cursor).

Selection to Nearest Frame
:   Round the time of each keyframe to the nearest frame.

Selection to Nearest Second
:   Round the time of each keyframe to the nearest second.
    You can use [Use Timecode](../introduction.xhtml#bpy-types-spacegrapheditor-show-seconds)
    to show seconds instead of frames at the top of the editor.

Selection to Nearest Marker
:   Set the time of each keyframe to that of the nearest [marker](../../../animation/markers.xhtml).

Flatten Handles
:   Flatten the *Bézier* handles for the selected keyframes.

    Flatten Handles snapping example.

    |  |  |
    | --- | --- |
    | ../../../_images/editors_graph-editor_fcurves_editing_flatten-handles-1.png   Before Flatten Handles. | ../../../_images/editors_graph-editor_fcurves_editing_flatten-handles-2.png   After Flatten Handles. |

Equalize Handles
:   Ensure selected keyframes’ handles have equal length.

    Side
    :   Which handles to affect (left, right, or both).

    Handle Length
    :   Length to make selected keyframes’ Bézier handles.

    Flatten
    :   Make the values of the handles the same as their respective keyframes.

Cursor to Selected `Ctrl`-`G`
:   Changes the time and value of the 2D Cursor to the average time and value of the selected keyframes.

Cursor Value to Selection
:   Changes the value of the 2D Cursor to the average value of the selected keyframes.
user: Explain ShaderNodeCombineXYZ(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeCombineXYZ(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeCombineXYZ(*ShaderNode*)
:   Create a vector from X, Y, and Z components

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # ShaderNodeWavelength(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeWavelength(*ShaderNode*)
:   Convert a wavelength value to an RGB value

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Image Editor
:   The path to an external program to use for image editing.

Animation Player
:   The program used for playing back rendered animations via
    [View Animation](../../interface/window_system/topbar.xhtml#topbar-render-view-animation).

    By default this is set to *Internal* which uses Blender’s built-in
    [animation player](../../render/output/animation_player.xhtml#bpy-ops-render-play-rendered-anim).

    This has the advantage that all image formats supported by Blender can be played back
    and no 3rd party application needs to be installed.

### Text Editor

Program
:   Command to launch the text editor when using [Edit Externally](../text_editor.xhtml#bpy-ops-text-jump-to-file-at-point),
    either a full path or a command in `$PATH`. Use the internal editor when left blank.

Arguments
:   Defines the specific format of the arguments with which the text editor opens files.

    The supported expansions are as follows:

    - `$filepath`: The absolute path of the file.
    - `$line`: The line to open at (Optional).
    - `$column`: The column to open from the beginning of the line (Optional).
    - `$line0` & `$column0` similar to the above but they start at zero.

    Example: `-f $filepath -l $line -c $column`
user: Provide the full official documentation entry for Known Limitations, preserving all code examples.

assistant: ### Archive Extraction

Extracting Blender’s archive using **7-zip** is not supported. TAR must be used instead. For more details, see issue
[#104070](https://projects.blender.org/blender/blender/issues/104070#issuecomment-1276521).
user: Explain Blender: Present And Future in complete detail according to the official Blender documentation.

assistant: In total, the Blender organization numbers some twenty-eight employees, working from Amsterdam, remotely, and on a
grant basis. For Blender, this team represents only a small part of a much wider community, which it defines as
everyone who contributes to Blender’s development, earns their living from Blender, or simply downloads it.

The Blender mission can be summed up as “get the world’s best 3d technology in the hands of artists as open-source,
and make amazing things with it.”

Going forward, Blender hopes to become a sustainable, future proof organization, dedicated to furthering its
open-source philosophy, its values of curiosity and innovation, a commitment to technical excellence, and increasingly
ambitious creative goals.
user: Explain Object Info Node in complete detail according to the official Blender documentation.

assistant: # Object Info Node

[image reference removed]

The *Object Info* node gives information about the object instance.
This can be useful to give some variation to a single material assigned to multiple instances,
either manually controlled through the object index, based on the object location,
or randomized for each instance. For example a Noise texture can give random colors or a Color
Ramp can give a range of colors to be randomly picked from.
user: Show practical ways to work with Capture Attribute Node in a Blender add-on or script – include code.

assistant: # Capture Attribute Node

[image reference removed]

The *Capture Attribute* node stores one or more fields on a geometry,
and outputs those same fields so they can be read by other nodes.

This storing and retrieving of a field can also be done with the
[Store Named Attribute Node](store_named_attribute.html)
and the [Named Attribute Node](../geometry/read/named_attribute.html)
respectively. The difference is that the *Capture Attribute* node creates
an [anonymous attribute](../attributes_reference.html#anonymous-attributes), meaning there’s no
need to specify a name and there’s no clutter at the end.
This makes the node ideal for temporary data storage.

A common use case is saving information that would normally be lost while
converting geometry – see the example below.
user: Describe Bpy.Types.Nodetreeinterfacesocketvectorvelocity2D from the Blender manual or Python API, including usage steps and snippets.

assistant: operties Inherited Functions
user: Describe Subdivide from the Blender manual or Python API, including usage steps and snippets.

assistant: # Subdivide

Subdividing adds resolution to the mesh by dividing faces or edges into smaller units.

This process follows a few rules depending on the situation:

- When only one edge of a triangle or [quad](../../../../glossary/index.xhtml#term-Quad) is selected,
  that face is turned into a quad or [N-gon](../../../../glossary/index.xhtml#term-N-gon) respectively.
  If the *Create N-Gons* option is disabled, the face is split into triangles instead.
- When two edges of a face are selected:

  - If the face is a triangle, a new edge is created between the two new vertices,
    subdividing the triangle into a triangle and a quad.
  - If the face is a quad and the edges are neighbors, the face is split according
    to the *Quad Corner Type* setting (see below).
  - If the face is a quad and the edges are opposite,
    the quad is just subdivided in two quads by the edge linking the two new vertices.
- When three edges of a face are selected:

  - If the face is a triangle, this means the whole face is selected and
    it is subdivided into four smaller triangles.
  - If the face is a quad, first the two opposite edges are subdivided as described above.
    Then, the “middle” edge is subdivided, affecting its new “sub-quad” as described above for only one edge.
- When all four edges of a quad are selected, the face is subdivided into four smaller quads.
- When one or more edges of an N-gon are selected,
  the individual edges will be subdivided but the face will stay unsubdivided.
user: Describe faces.super_face from the Blender manual or Python API, including usage steps and snippets.

assistant: Will create a face system based on the bones child to the parent that has the property set on it.

Requirement: All the face bones bundled in the `faces.super_face` sample had to be present and
child of the master bone that has the Rigify type *face* property set.
user: How do I use Surface Response in Blender? Include parameters, examples, warnings and best practices.

assistant: Friction
:   Resistance of object to movement. Specifies how much velocity is lost when objects collide with each other.

Bounciness
:   Tendency of object to bounce after colliding with another (0 to 1) (rigid to perfectly elastic).
    Specifies how much objects can bounce after collisions.
user: What is Shrinkwrap Modifier and how is it used in Blender Python scripting?

assistant: # Shrinkwrap Modifier

The *Shrinkwrap* modifier allows a Grease Pencil object to “shrink” to the surface of another object.
It moves each point of the object being modified to the closest position on the surface of the given mesh.
user: How do I use ShaderFxShadow(ShaderFx) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderFxShadow(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.ShaderFxShadow(*ShaderFx*)
:   Shadow effect

    amplitude
    :   Amplitude of Wave

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

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

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

    object
    :   Object to determine center of rotation

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

    offset
    :   Offset of the shadow

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

    orientation
    :   Direction of the wave

        Type:
        :   enum in [`'HORIZONTAL'`, `'VERTICAL'`], default `'HORIZONTAL'`

    period
    :   Period of Wave

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

    phase
    :   Phase Shift of Wave

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

    rotation
    :   Rotation around center or object

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

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

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

    scale
    :   Scale of the shadow

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    shadow_color
    :   Color used for Shadow

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

    use_object
    :   Use object as center of rotation

        Type:
        :   boolean, default False

    use_wave
    :   Use wave effect

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

assistant: Show Locations – Recent
:   Hide the *Recent* panel of the [File Browser](../file_browser.xhtml)
    which displays recently accessed folders.

Show Locations – System
:   Hide System Bookmarks in the *File Browser*.

Defaults – Filter Files
:   By activating this, the file region in the File Browser will only show appropriate files
    (i.e. blend-files when loading a complete Blender setting).
    The selection of file types may be changed in the file region.

Defaults – Show Hidden Files/Data-Blocks
:   Unhide files and data-blocks with names that start with `.` in File Browsers
    and [data IDs](../../interface/controls/templates/data_block.xhtml#ui-data-block).
user: What is Flip Quad Tessellation and how is it used in Blender Python scripting?

assistant: Internally, all [quads](../../../../glossary/index.xhtml#term-Quad) are [Tessellated](../../../../glossary/index.xhtml#term-Tessellation) into 2 triangles,
this operator swaps which way the quad is split into triangles.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_face_flip-tesselation_before.png | ../../../../_images/modeling_meshes_editing_face_flip-tesselation_after.png |
user: Provide the full official documentation entry for Extrude Edges, preserving all code examples.

assistant: # Extrude Edges

Extrude edges as individual edges.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_edge_extrude-edges_before.png>   Edge selected. | <../../../../_images/modeling_meshes_editing_edge_extrude-edges_after.png>   Edge extruded. |
user: Show practical ways to work with TransformOrientationSlot(bpy_struct) in a Blender add-on or script – include code.

assistant: # TransformOrientationSlot(bpy_struct)

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

*class* bpy.types.TransformOrientationSlot(*bpy_struct*)
:   custom_orientation
    :   Type:
        :   [`TransformOrientation`](bpy.types.TransformOrientation.html#bpy.types.TransformOrientation "bpy.types.TransformOrientation"), (readonly)

    type
    :   Transformation orientation

        Type:
        :   enum in [Transform Orientation Items](bpy_types_enum_items/transform_orientation_items.html#rna-enum-transform-orientation-items), default `'GLOBAL'`

    use
    :   Use scene orientation instead of a custom setting

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.TransformOrientationSlot.type "bpy.types.TransformOrientationSlot.type")
user: How do I use Roll Hair Curves in Blender? Include parameters, examples, warnings and best practices.

assistant: # Roll Hair Curves

The *Roll Hair Curves* node coils or curls the tips of hair curves, rolling them inward or outward
based on configurable geometric parameters.
This node can be used to create spiral or curled hairstyles, simulate rolled fur, or stylize hair motion.
user: Give a detailed overview of The Home Location of Assets: syntax, arguments, return values, common patterns.

assistant: There can be as many catalogs as you want, but **an asset can be assigned to a single catalog** at a time.
This is similar to a file system, where a file is only in one directory
(ignoring advanced things like symbolic links).

Catalogs themselves can be nested and moved by dragging and dropping.
Moving a catalog will not modify the assets it contains; they will simply move along
to the new location of the catalog.

Selecting a catalog in the Asset Browser will show all assets in that catalog and in child catalogs.
So, in the preceding example, selecting `Characters/Ellie/Poses` will also show assets from
`Characters/Ellie/Poses/Head` and `Characters/Ellie/Poses/Hands`.
user: How do I use Grab in Blender? Include parameters, examples, warnings and best practices.

assistant: # Grab

Drag geometry across the screen, following the cursor.
*Grab* only moves the vertices that are under the brush radius at the start of the stroke.
This is an essential sculpting brush to be used frequently to build shapes and adjust proportions.

[image reference removed]
user: What is Inputs and how is it used in Blender Python scripting?

assistant: The inputs are dynamic, they become available if needed depending on the node properties.

Vector
:   Texture coordinate to evaluate the noise at;
    defaults to *Generated* texture coordinates if the socket is left unconnected.

W
:   Texture coordinate to evaluate the noise at.

Scale
:   Scale of the noise.

Detail
:   Number of noise octaves.
    The fractional part of the input is multiplied by the magnitude of the highest octave.
    Higher number of octaves corresponds to a higher evaluation time.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Lacunarity
:   The difference between the scale of each two consecutive octaves.
    Larger values corresponds to larger scale for higher octaves.

Smoothness
:   The smoothness of the noise.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-zero.png   Smoothness: 0.0. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-quarter.png   Smoothness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-half.png   Smoothness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-one.png   Smoothness: 1.0. |
    | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-zero.png   Smoothness: 0.0. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-quarter.png   Smoothness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-half.png   Smoothness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-one.png   Smoothness: 1.0. |

Exponent
:   Exponent of the Minkowski distance metric.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-half.png   Exponent: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-one.png   Exponent: 1.0. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-two.png   Exponent: 2.0. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-32.png   Exponent: 32.0. |

Randomness
:   The randomness of the noise.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_randomness-one.png   Randomness: 1.0. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-half.png   Randomness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-quarter.png   Randomness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-zero.png   Randomness: 0.0. |
user: How do I use Fill Holes in Blender? Include parameters, examples, warnings and best practices.

assistant: Fills each hole in the selected geometry with a face.

Sides
:   The maximum number of sides: if a hole has more edges than this number,
    it will not be filled. You can set this limit to 0 to fill all holes.
user: What is Data Transfer Modifier and how is it used in Blender Python scripting?

assistant: # Data Transfer Modifier

The *Data Transfer* modifier copies certain types of data from an external mesh
to the modified one. This could be [UV maps](../../../editors/uv/introduction.xhtml),
[color attributes](../../meshes/properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes),
[custom normals](../../meshes/structure.xhtml#modeling-meshes-normals-custom), and so on.

For each element (vertex/edge/face) in the modified mesh, the modifier finds one
or more matching elements in the source mesh, then interpolates between those source
elements’ values.

[image reference removed]

Transferring a UV map from a low resolution mesh to a high resolution one
using interpolation.
user: Explain CompositorNodeIDMask(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeIDMask(CompositorNode)

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

*class* bpy.types.CompositorNodeIDMask(*CompositorNode*)
:   Create a matte from an object or material index pass

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Delete Active Keyframe (Active Layer): syntax, arguments, return values, common patterns.

assistant: Deletes the last keyframe in the Dope Sheet or the current keyframe if you are on one.

Type
:   Pick which layer to delete keyframes.

    Active Frame:
    :   Deletes current frame in the active layer.

    All Active Frames:
    :   Delete active frames for all layers.
user: Provide the full official documentation entry for Select Similar, preserving all code examples.

assistant: Children
:   Extends the selection to all hierarchical descendant bones.

Immediate Children
:   Extends the selection to all direct child bones.

Siblings
:   Selects bones that have the same parent as the active bone.

Length
:   Selects bones with a similar [bone length](properties/transform.html#bpy-types-editbone-length) under the specified *Threshold*.

Direction (Y axis)
:   Select bones aligned on the Y axis (along the bone’s length).

Prefix
:   Select bones with matching name prefix (separated by `.`).

Suffix
:   Select bones with matching name suffix (separated by `.`).

Bone Collection
:   Select bones that share one or more bone collections with the active bone.

Color
:   Select bones that have the same color as the active bone.

Shape
:   Select bones using the same shape object (in Pose Mode).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   The input geometry containing the hair curves to be rotated.

Factor
:   Controls the overall strength of the rotation.
    A value of 0.0 disables the effect, while 1.0 applies the full rotation angle.

Axis
:   Defines the axis around which each curve is rotated.
    By default, the tangent direction at the root of each curve is used.

Angle
:   Specifies the amount of rotation applied around the chosen axis, in radians.
    Positive values rotate in one direction, negative values in the opposite.

Random Offset
:   Adds a random offset to the rotation angle for each curve, introducing natural variation
    and avoiding a uniform appearance.

Lock Ends
:   When enabled, constrains the deformation to preserve the relative position between
    the root and tip of each curve.
    This helps maintain the overall direction and placement of the hair strands.

Seed
:   Sets the random seed used for generating the random offsets.
    Changing this value produces different randomized rotation patterns while keeping the same parameters.
user: What is Usage and how is it used in Blender Python scripting?

assistant: # Usage

For example, we will take an existing blend-file
that was made for monoscopic rendering and transform it to be stereo 3D ready.

[image reference removed]

Creature Factory 2 by Andy Goralczyk rendered in stereo 3D (anaglyph).
user: Show practical ways to work with Script Loading in a Blender add-on or script – include code.

assistant: This may seem obvious, but it is important to note the difference between
executing a script directly and importing a script as a module.

Extending Blender by executing a script directly means the classes that the script defines
remain available inside Blender after the script finishes execution.
Using scripts this way makes future access to their classes
(to unregister them for example) more difficult compared to importing the scripts as modules.
When a script is imported as a module, its class instances will remain
inside the module and can be accessed later on by importing that module again.

For this reason it is preferable to avoid directly executing scripts that extend Blender by registering classes.

Here are some ways to run scripts directly in Blender:

- Loaded in the text editor and press *Run Script*.
- Typed or pasted into the interactive console.
- Execute a Python file from the command line with Blender, e.g:

  ```
  blender --python /home/me/my_script.py
  ```

To run as modules:

- The obvious way, `import some_module` command from the text editor or interactive console.
- Open as a text data-block and check the *Register* option, this will load with the blend-file.
- Copy into one of the directories `scripts/startup`, where they will be automatically imported on startup.
- Define as an add-on, enabling the add-on will load it as a Python module.

### Add-ons

Some of Blender’s functionality is best kept optional,
alongside scripts loaded at startup there are add-ons which are kept in their own directory `scripts/addons`,
They are only loaded on startup if selected from the user preferences.

The only difference between add-ons and built-in Python modules is that add-ons must contain a `bl_info` variable
which Blender uses to read metadata such as name, author, category and project link.
The User Preferences add-on listing uses `bl_info` to display information about each add-on.
[See Add-ons](https://developer.blender.org/docs/handbook/addons/guidelines/)
for details on the `bl_info` dictionary.