PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Fillet Curve Node and how is it used in Blender Python scripting?

assistant: # Fillet Curve Node

[image reference removed]

The *Fillet Curve* rounds corners on curve control points, similar to the effect of
the [Bevel Modifier](../../../modifiers/generate/bevel.xhtml) on a 2D mesh.
However, a key difference is that the rounded portions created by the Fillet Curve node
are always portions of a circle.
user: What is ShaderFxColorize(ShaderFx) and how is it used in Blender Python scripting?

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

    factor
    :   Mix factor

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

    high_color
    :   Second color used for effect

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

    low_color
    :   First color used for effect

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

    mode
    :   Effect mode

        Type:
        :   enum in [`'GRAYSCALE'`, `'SEPIA'`, `'DUOTONE'`, `'TRANSPARENT'`, `'CUSTOM'`], default `'GRAYSCALE'`

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

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

assistant: [image reference removed]

Curve Pen Preferences

The following preferences can be configured from:
Preferences ‣ Keymap ‣ 3D View ‣ Curve ‣ 3D View Tool: Edit Curve, Curve Pen.

Extrude Point
:   `LMB` click to add a new point connected to an existing point.

Extrude Handle Type
:   The [handle type](../structure.xhtml#curve-bezier-handle-type) of the extruded points.
    Can be either *Vector* or *Auto*.
    However, the handle type switches to *Align* when handles are moved (See *Move Point*).

Delete Point
:   `Ctrl`-`LMB` click on an existing point to delete it.

Insert Point
:   `Ctrl`-`LMB` click on a [Curve Segment](../../../glossary/index.xhtml#term-Curve-Segment) to insert a new control point between the two
    adjacent control points. `Ctrl`-`LMB` click and drag to control the handles of the inserted points.

Move Segment
:   `LMB` drag on a segment in between two control points to adjust the handles, changing the shape of the
    curve without affecting the location of any control points.

Select Point
:   `LMB` click to select a single point or handle at a time.

Move point
:   `LMB` drag to move existing points or handles. With an endpoint of a spline selected,
    click and drag on empty space to *Extrude Point* and move the handle at the same time.

Close Spline
:   Make the spline [Cyclic](../../../glossary/index.xhtml#term-Cyclic) by clicking the endpoints consecutively.

Close Spline Method
:   The condition for *Close Spline* to activate.

    None:
    :   Turn off the Close Spline functionality.

    On Press:
    :   Close the spline on mouse down. With this option, you may click and drag to adjust the handles of the endpoint.

    On Click:
    :   Activate on mouse release. With this option, the *Close Spline* functionality will not be
        triggered on click and drag.

Toggle Vector
:   Double `LMB` click on a handle to switch handle between *Vector* and *Auto* handle types.
    Can be used to easily switch between sharp corners and smooth curves.

Cycle Handle Type
:   Double `LMB` click on the control point to cycle through all handle types.
user: Give a detailed overview of Window System Introduction: syntax, arguments, return values, common patterns.

assistant: # Window System Introduction

After starting Blender and closing the [Splash Screen](splash.xhtml#splash),
the Blender window should look similar to the image below.

[image reference removed]

The default startup Blender window.

Blender’s interface is separated into three main parts:

- The [Topbar](topbar.xhtml) at the very top, consists of the main menu,
  which is used for saving, importing and exporting files, configuring settings, and rendering among other functions.
- [Areas](areas.xhtml) in the middle, which is the main workspace.
- The [Status Bar](status_bar.xhtml) at the bottom,
  which displays shortcut suggestions and relevant statistics.

[image reference removed]

Blender’s default Screen Layout. Topbar (blue), Areas (green) and Status Bar (red).
user: Give a detailed overview of Nodes: syntax, arguments, return values, common patterns.

assistant: ### UV Along Stroke Node

[image reference removed]

UV Along Stroke Node.

The *UV Along Stroke* input node is maps textures along the stroke length,
making it possible to mimic pencil, paintbrush, and other art medium marks.

#### Inputs

This node has no inputs.

#### Properties

Use Tips
:   Allows to use lower quarters of a texture image for the head and tail tips of a stroke,
    while the upper half for the stroke body.

#### Outputs

UV
:   UV maps defined along strokes.

### Line Style Output Node

[image reference removed]

Line Style Output Node.

The *Line Style Output* node specifies how to mix the texture information
into the base color of line styles.

#### Inputs

Color
:   Color input for the texture.

Color Factor
:   Standard mix factor of the *Color* value.

Alpha
:   Alpha input for the texture.

Alpha Factor
:   Standard mix factor of the *Alpha* value.

#### Properties

Mix
:   The Blend mode can be selected in the select menu.
    See [Color Blend Modes](../../../../glossary/index.html#term-Color-Blend-Modes) for details on each blending mode.

Clamp
:   Limit the highest color value to not exceed 1.0.

#### Outputs

This node has no outputs.
user: Provide the full official documentation entry for ThemeCommonCurves(bpy_struct), preserving all code examples.

assistant: # ThemeCommonCurves(bpy_struct)

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

*class* bpy.types.ThemeCommonCurves(*bpy_struct*)
:   Shared curve theme properties

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

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

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

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

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

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

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

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

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

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

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

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

    handle_vertex_size
    :   Type:
        :   int in [1, 100], default 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 Video and how is it used in Blender Python scripting?

assistant: ### Output

Videos can be rendered with both wide gamut and HDR color spaces. They use the scene display
by default, but can also be assigned a different color space by overriding the color management
settings in the output properties.

Saving HDR videos has a few additional requirements:

- Set color management display to Rec.2100 PQ or HLG
- Set codec to H.265 or AV1
- Set bit depth to 10 or 12

Video players and devices have different levels of support for HDR video.
Bit depth 10 with PQ encoding is a good default choice to maximize compatibility.

HDR videos are written with 100 nits diffuse white, to match the convention in most video
players and browsers.
user: Give a detailed overview of Image Tab: syntax, arguments, return values, common patterns.

assistant: ### UV Vertex

The averaged-out position of the selected UV vertices.

### Image

See [Image Settings](../image/image_settings.xhtml).

### UDIM Tiles

See [UDIM Tiles](../../modeling/meshes/uv/workflows/udims.xhtml).
user: Explain Tracks in complete detail according to the official Blender documentation.

assistant: # Tracks

A track plays one or more actions in sequence. You can create multiple tracks to play
several actions at the same time.

[image reference removed]

NLA Tracks and Strips.

The track region has the following properties:

Disable NLA stack (checkbox in blue object header)
:   When unchecked, mutes all the tracks except the Action Track.

Track name
:   Double-click to change. (Not possible for the Action Track, as this one simply displays the
    name of the action.)

Mute (checkbox in gray track header)
:   When unchecked, the track stops contributing to the animation. Its strips receive a dotted outline
    to indicate this. Note that you can also mute individual strips.

Lock (padlock icon)
:   Prevents changes from being made to this track.
    This is useful, for example, if you want to move the strips in all the tracks except for a few.

Solo (star icon)
:   Mutes all other tracks, including the Action Track, so that only this track contributes
    to the animation. This is useful for inspecting the track without any distractions from others.
user: What is Usage and how is it used in Blender Python scripting?

assistant: This add-on allows you to export a UV map as an image:
(UV Editor ‣ UV ‣ Export UV Layout)
It allows you to export to `PNG`, `EPS`, or `SVG` format.
The desired UV faces must be selected in the 3D View, not the UV Editor.

The image will be lines defining the UV edges that are within the default grid of the UV Editor.
Edges outside this boundary, even if selected, will not be shown in the saved graphic.

You can then bring this image into your favorite painting program,
and use it as a transparent reference guide to create a texture.
Then export that image and load it back into Blender as part of a material set-up.
For using images as textures, see the page on
[Image Textures](../../render/materials/legacy_textures/types/image_movie.xhtml).

|  |  |
| --- | --- |
| ../../_images/addons_import-export_mesh-uv-layout_uv-editor.png   A UV layout in the UV Editor. | ../../_images/addons_import-export_mesh-uv-layout_export.png   A UV layout in a paint program. |
user: Describe AttributeGroupCurves(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # AttributeGroupCurves(bpy_struct)

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

*class* bpy.types.AttributeGroupCurves(*bpy_struct*)
:   Group of geometry attributes

    active
    :   Active attribute

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

    active_index
    :   Active attribute index or -1 when none are active

        Type:
        :   int in [-1, inf], default 0

    new(*name*, *type*, *domain*)
    :   Add attribute to geometry

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name, Name of geometry attribute
            - **type** (enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items)) – Type, Attribute type
            - **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   New geometry attribute

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

    remove(*attribute*)
    :   Remove attribute from geometry

        Parameters:
        :   **attribute** ([`Attribute`](bpy.types.Attribute.html#bpy.types.Attribute "bpy.types.Attribute"), (never None)) – Geometry Attribute

    domain_size(*domain*)
    :   Get the size of a given domain

        Parameters:
        :   **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   Size, Size of the domain

        Return type:
        :   int in [0, inf]

    *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 Set Curve Type, preserving all code examples.

assistant: Converts splines in a curve object between Bézier, NURBS, Poly, and Catmull Rom types.
This is a basic conversion, meaning Blender does not preserve the exact shape or the number of control points.
For example, converting a NURBS spline to a Bézier spline maps each group of three NURBS control points
to a single Bézier control point with two handles.

Type
:   Specifies the target spline type. For more details on spline types, see the
    [Spline Types](../../curves/structure.html#curve-spline-types) documentation.

    Bézier:
    :   Converts the spline to a Bézier type.
        - Poly splines are converted with vector handles.
        - NURBS or Catmull Rom splines are converted with automatic handles.

    NURBS:
    :   Converts the spline to a NURBS type.

    Poly:
    :   Converts the spline to a poly type.

    Catmull Rom:
    :   Converts the spline to a Catmull Rom type.

Handles
:   Includes handle information during the conversion process.
user: Describe ForeachGeometryElementZoneViewerPathElem(ViewerPathElem) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ForeachGeometryElementZoneViewerPathElem(ViewerPathElem)

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

*class* bpy.types.ForeachGeometryElementZoneViewerPathElem(*ViewerPathElem*)
:   zone_output_node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Attributes

An *attribute* is a generic term to describe data stored per-element in a geometry data-block.
For example, every vertex can have an associated number or vector.
Attributes can be altered by connecting a value to the *Group Output* node,
but also many nodes can change the values of specific attributes.
user: What is Guiding Lines and how is it used in Blender Python scripting?

assistant: # Guiding Lines

The *Guiding Lines* modifier replaces a stroke by a straight line connecting both of its ends.

Offset
:   Offset the start and end points along the original stroke, before generating the new straight one.

This modifier will produce reasonable results when strokes are short enough,
because shorter strokes are more likely to be well approximated by straight lines.
Therefore, it is recommended to use this modifier together with one of the splitting options
(by 2D angle or by 2D length) from the *Strokes* panel.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_geometry_guiding-lines_example.png)

Guiding Lines modifier Demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_Guiding_Line.zip)).
user: What is Seams and how is it used in Blender Python scripting?

assistant: # Seams

For many cases, using the Unwrap calculations of Cube, Cylinder, Sphere,
or the regular “Unwrap” operators will produce a good UV layout.
But for more complex meshes, especially those with lots of indentations,
you may want to define a *seam* to limit and guide the [Unwrap](../../editing/uv.xhtml#bpy-ops-uv-unwrap) operator.

Just like in sewing, a seam is where the ends of the image/cloth are sewn together.
In unwrapping, the UV map is discontinuous at the seams.
Think of this method as peeling an orange or skinning an animal.
You make a series of cuts in the skin, then peel it off. You could then flatten it out,
applying some amount of stretching. These cuts are the same as seams.

[image reference removed]

Simple seam on a cylinder.

When using this method, you need to be aware of how much stretching there is.
The more seams there are, the less stretching there is,
but this is often an issue for the texturing process.
It is a good idea to have as few seams as possible while having the least amount of stretching.
Try to hide seams where they will not be seen. In productions where 3D paint is used,
this becomes less of an issue, as projection painting can easily deal with seams,
as opposed to 2D texturing, where it is difficult to match the edges of different UV islands.

The workflow is the following:

1. Mark seams.
2. Unwrap.
3. Adjust seams and repeat.
4. Manually adjust UVs.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Vector
:   Vector of the input system that is to be divided into radial segments.

Sides
:   Number of radial segments to divide the input coordinate system into.
    A non-integer value results in an irregular segment that is smaller than the regular segments.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_0.png   Sides: 5.0. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_25.png   Sides: 5.25. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_5.png   Sides: 5.5. | ../../../../_images/render_shader-nodes_radial_tiling_segments-6_0.png   Sides: 6.0. |

Roundness
:   Roundness of the segment coordinate systems.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_0.png   Roundness: 0.0. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_25.png   Roundness: 0.25. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_5.png   Roundness: 0.5. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-1_0.png   Roundness: 1.0. |
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Data Type
:   The data type that is used for mixing.
    The node supports float, vector, color, and rotation data types.

Factor Mode (Vector only)
:   The factor mode can be set to *Uniform* and *Non-Uniform*.
    In uniform mode, a single float controls the factor.
    In non-uniform mode, a vector controls the factor for
    each XYZ channel separately.

Mix (Color only)
:   The Blend modes can be selected in the select menu.
    See [Color Blend Modes](../../../glossary/index.xhtml#term-Color-Blend-Modes) for details on each blending mode.

    Add, Subtract, Multiply, Screen, Divide, Difference,
    Darken, Lighten, Overlay, Color Dodge, Color Burn,
    Hue, Saturation, Value, Color, Soft Light, Linear Light

Clamp Factor
:   Limit the factor value between 0.0 and 1.0. If this option is
    unchecked then the node operates using *Extrapolation*.

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Explain Brush Asset in complete detail according to the official Blender documentation.

assistant: # Brush Asset

[image reference removed]

Brush data-block panel.

Brush
:   The [Data-Block Menu](../../../../interface/controls/templates/data_block.html#ui-data-block) to select a preset brush type or a custom brush.

    Add Brush
    :   When you add a brush, the new brush is a clone of the current one.

    Brush Specials
    :   Reset Brush
        :   Reset the current brush to its default settings.

        Reset All Brushes
        :   Reset all brushes to their default settings.

        Custom Icon
        :   Allows definition of a custom brush icon.

            Image Path
            :   Defines the path to the image to use as custom icon.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: A locked axis will display in a brighter color than an unlocked axis. For example in the image to the right,
the Z axis is shown in light blue as movement is constrained to this axis. This example, can be achieved in two ways:

### Hotkey

The axis of movement can be changed at any time during transformation by typing `X`, `Y`, `Z`.

### Pointing

[image reference removed]

Axis constraint in action.

Holding `MMB` after starting a transformation lets you select an axis to constrain to.
A visual option to constrain the translation will be available,
showing the three axes in the 3D Viewport space. A dotted white line is used as a pointer.
The axis of choice to confirm the operation
will depend on the highlighted axis about which the `MMB` is released.

When you already moved the mouse in the desired direction,
pressing `MMB` will lock to the axis which was pointed at.
user: Provide the full official documentation entry for ID Mask Node, preserving all code examples.

assistant: # ID Mask Node

[image reference removed]

The *ID Mask Node* creates a mask for a particular object or material in the render.
It relies on the *Object Index* or *Material Index* [render pass](../../../render/layers/passes.xhtml),
which is only available when rendering with Cycles.
user: Describe Limit Rotation Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Limit Rotation Constraint

The *Limit Rotation* constraint limits the Euler rotation angle for each axis
to a certain range.

Angles outside a range are clamped to whichever boundary is closer on a circle.
For example, if an axis is limited to the range 0°-90° and the original rotation
is 340°, the constraint changes this to 0°, not 90°.

This constraint doesn’t work for bones that are affected by [Inverse Kinematics](../../armatures/posing/bone_constraints/inverse_kinematics/introduction.xhtml).
Please use the *Limit* settings in the bone’s [IK panel](../../armatures/posing/bone_constraints/inverse_kinematics/introduction.xhtml#bpy-types-posebone-ik)
instead.
user: What is EEVEE Support and how is it used in Blender Python scripting?

assistant: EEVEE has no real concept of rays, but in order to ease the workflow between Cycles and EEVEE,
some of the outputs are supported in particular cases.

- *Is Camera*: Supported.
- *Is Shadow*: Supported.
- *Is Diffuse*: Supported.
- *Is Glossy*: Supported.
- *Is Singular*: Not supported. Same as *Is Glossy*.
- *Is Reflection*: Not supported. Same as *Is Glossy*.
- *Is Transmission*: Not supported. Same as *Is Glossy*.
- *Ray Length*: Distance from the camera to the shading point.
- *Ray Depth*: Indicates the current bounce when baking the light cache.
- *Diffuse Depth*: Same as Ray Depth but only when baking diffuse light.
- *Glossy Depth*: Same as Ray Depth but only when baking specular light.
- *Transparent Depth*: Not supported. Defaults to 0.
- *Transmission Depth*: Not supported. Same as *Glossy Depth*.
user: What is Sound Strip and how is it used in Blender Python scripting?

assistant: # Sound Strip

As well as images and movies the Video Sequencer can also edit audio tracks.
You can add Waveform Audio format `WAV`, `mp3` and other audio formats files from your drive,
or from sound encoded within a movie, and mix them using an F-Curve as a volume control.

[image reference removed]

Example of sound editing.
user: Give a detailed overview of FunctionNodeInputColor(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeInputColor(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.FunctionNodeInputColor(*FunctionNode*)
:   Output a color value chosen with the color picker widget

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

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

assistant: In the supported editors, if at least one is created, markers are visualized
in a separate row at their bottom.
This area can be disabled per editor via the View ‣ Show Markers menu option.

### Standard

[image reference removed]

Regular markers are shown as small white triangles, empty if unselected or filled if selected,
and with a dashed line that covers the editor height at the corresponding frame.
If they have a name, this is shown to their right in white.

### 3D Viewport

[image reference removed]

The 3D Viewport does not allow you to create, edit or remove markers,
but it shows their name in the Object Info in the upper left corner,
when on their frame.

### Pose Markers

[image reference removed]

Pose markers show a diamond-shaped icon in the Dope Sheet.
In the NLA editor pose markers are shown as a red dashed line inside the relative action strip.
user: How do I use Shrinkwrap Hair Curves in Blender? Include parameters, examples, warnings and best practices.

assistant: # Shrinkwrap Hair Curves

The *Shrinkwrap Hair Curves* node projects hair curves onto a target surface,
adjusting their positions so they follow the shape of a mesh.
It can be used to conform hair to a scalp or other underlying geometry,
ensuring curves remain properly positioned relative to a surface.
user: Show practical ways to work with basic.super_copy in a Blender add-on or script – include code.

assistant: Single-bone rig type that simply copies the bone. Useful as utility rig type for
adding custom features or specific deform bones to your rigs.

Control (Boolean)
:   When enabled a control bone and widget will be created.

Widget (Boolean)
:   When enabled a widget will be created in replacement to the standard.

Widget Type (String):
:   Allows selecting one of the predefined widget types to generate instead of the default circle.

Deform (Boolean)
:   When enabled a deform bone will be created.

Relink Constraints
:   Works the same as in the [basic.raw_copy](#basic-raw-copy) rig. In addition, when enabled any constraints that have
    names prefixed with `CTRL:` are moved to the control, and with `DEF:` to the deform bone.
user: Give a detailed overview of Hook Modifier: syntax, arguments, return values, common patterns.

assistant: # Hook Modifier

The *Hook* Modifier is used to deform stroke points using another object
(usually an empty or a bone but it can be any object).

As the hook moves, it pulls points from the strokes with it.
You can think of it as animated
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml).
user: Describe Weight Paint Overlays from the Blender manual or Python API, including usage steps and snippets.

assistant: Opacity
:   The opacity of the overlay.

Zero Weights
:   Display unreferenced and zero-weighted areas in black.
    This helps to identify areas with very low weights that have been painted onto.

    None:
    :   Vertices are displayed in the usual way.

    Active:
    :   Vertices are shown in black if they have no weight in the active vertex group.

    All:
    :   Vertices are shown in black if they have no weight in any vertex group.

Show Weight Contours
:   Show contour lines formed by points with the same interpolated weight.

    This visualizes weight variations too small to be seen from colors and can be useful for judging
    the smoothness and consistency of gradients, e.g. when using smoothing tools and brushes.

Show Wire
:   Display mesh edges in white (unlike the *Wireframe* overlay which shows them in black).
user: What is GreasePencilLayerMask(bpy_struct) and how is it used in Blender Python scripting?

assistant: # GreasePencilLayerMask(bpy_struct)

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

*class* bpy.types.GreasePencilLayerMask(*bpy_struct*)
:   List of Mask Layers

    hide
    :   Set mask Visibility

        Type:
        :   boolean, default False

    invert
    :   Invert mask

        Type:
        :   boolean, default False

    name
    :   Mask layer name

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: 1. Shift-select the object to be parented (the child object).
2. Select the parent mesh object and enter *Edit Mode*.
3. Select **one or three** vertices that will define the parent relationship.
4. Press `Ctrl`-`P`
user: What is Template Contents and how is it used in Blender Python scripting?

assistant: Each of the following files can be used for application templates but are optional.

`startup.blend`
:   Factory startup file to use for this template.

`userpref.blend`
:   Factory preferences file to use for this template.
    When omitted preferences are shared with the default Blender configuration.

    *(As noted previously, this is only used for a subset of preferences).*

`splash.png`
:   Splash screen to override Blender’s default artwork (not including header text).
    Note, this image must be a `1000x500` image.

`__init__.py`
:   A Python script which must contain `register` and `unregister` functions.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: Consider a node setup for green screen removal, using
a [Color Key](color_key.xhtml):

[image reference removed]

Often, lighting is uneven across the backdrop.

[image reference removed]

Example from the [Mango Open Movie](https://mango.blender.org/), Tears of Steel.

That can result in a bad matte.

[image reference removed]

Example of a poor mask: Some of the backdrop is opaque,
and some parts of the gun in the foreground are transparent.

If you increase the tolerances on the Color Key node, it will accept
more shades of green to mask out. But it may also incorrectly mask out more of
the foreground.

Instead of increasing the range of accepted shades to be masked out,
the Keying Screen node lets you change what shade of green (or other color) to used
for different parts of the image.

Start in the [Movie Clip Editor](../../../editors/clip/index.xhtml).
Open the Sidebar region and Toolbar to show tracking configuration.
Tracks used for gradients are not useful for camera solving, because they do not track well.
So create a new object track in the *Objects* selector.
Place tracking markers on the clip to sample different parts of the backdrop.

[image reference removed]

These tracks may be tracked or moved manually, so gradients can be updated
over time. If the marker is not enabled for a frame, it will not be used creating
the gradient. (Such as the red-colored marker on the arm in the screenshot above)

Once the tracks are created, add the node to your compositing setup,
and select the tracking object used for the backdrop.

[image reference removed]

Node configuration with *Keying Screen*’s generated gradient
plate connected to the Color input of the Keying node.

[image reference removed]

Gradient plate generated by *Keying Screen*.

The resulting image now has a better matte.

[image reference removed]
user: Give a detailed overview of NodeSocketVectorFactor2D(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketVectorFactor2D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorFactor2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Node Math Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Node Math Items

**Functions**

ADD:
:   Add.

    A + B.

SUBTRACT:
:   Subtract.

    A - B.

MULTIPLY:
:   Multiply.

    A \* B.

DIVIDE:
:   Divide.

    A / B.

MULTIPLY_ADD:
:   Multiply Add.

    A \* B + C.

---

POWER:
:   Power.

    A power B.

LOGARITHM:
:   Logarithm.

    Logarithm A base B.

SQRT:
:   Square Root.

    Square root of A.

INVERSE_SQRT:
:   Inverse Square Root.

    1 / Square root of A.

ABSOLUTE:
:   Absolute.

    Magnitude of A.

EXPONENT:
:   Exponent.

    exp(A).

**Comparison**

MINIMUM:
:   Minimum.

    The minimum from A and B.

MAXIMUM:
:   Maximum.

    The maximum from A and B.

LESS_THAN:
:   Less Than.

    1 if A < B else 0.

GREATER_THAN:
:   Greater Than.

    1 if A > B else 0.

SIGN:
:   Sign.

    Returns the sign of A.

COMPARE:
:   Compare.

    1 if (A == B) within tolerance C else 0.

SMOOTH_MIN:
:   Smooth Minimum.

    The minimum from A and B with smoothing C.

SMOOTH_MAX:
:   Smooth Maximum.

    The maximum from A and B with smoothing C.

**Rounding**

ROUND:
:   Round.

    Round A to the nearest integer. Round upward if the fraction part is 0.5.

FLOOR:
:   Floor.

    The largest integer smaller than or equal A.

CEIL:
:   Ceil.

    The smallest integer greater than or equal A.

TRUNC:
:   Truncate.

    The integer part of A, removing fractional digits.

---

FRACT:
:   Fraction.

    The fraction part of A.

MODULO:
:   Truncated Modulo.

    The remainder of truncated division using fmod(A,B).

FLOORED_MODULO:
:   Floored Modulo.

    The remainder of floored division.

WRAP:
:   Wrap.

    Wrap value to range, wrap(A,B).

SNAP:
:   Snap.

    Snap to increment, snap(A,B).

PINGPONG:
:   Ping-Pong.

    Wraps a value and reverses every other cycle (A,B).

**Trigonometric**

SINE:
:   Sine.

    sin(A).

COSINE:
:   Cosine.

    cos(A).

TANGENT:
:   Tangent.

    tan(A).

---

ARCSINE:
:   Arcsine.

    arcsin(A).

ARCCOSINE:
:   Arccosine.

    arccos(A).

ARCTANGENT:
:   Arctangent.

    arctan(A).

ARCTAN2:
:   Arctan2.

    The signed angle arctan(A / B).

---

SINH:
:   Hyperbolic Sine.

    sinh(A).

COSH:
:   Hyperbolic Cosine.

    cosh(A).

TANH:
:   Hyperbolic Tangent.

    tanh(A).

**Conversion**

RADIANS:
:   To Radians.

    Convert from degrees to radians.

DEGREES:
:   To Degrees.

    Convert from radians to degrees.
user: Explain Marker Display in complete detail according to the official Blender documentation.

assistant: Determines how markers are displayed in the editor.

Pattern
:   Whether to show the pattern areas of tracks. Can be used to reduce clutter and
    check how good tracking is.

Search `Alt`-`S`
:   Whether to show the search areas of *selected* tracks. Can be used to reduce clutter and
    check how good tracking is.

Path
:   Shows past (red) and future (blue) positions of tracks relative to the current frame,
    visualizing how they move. This makes it easier to spot irregularities.

Length
:   Length (in frames) of the *Path*.

Show Disabled `Alt`-`D`
:   When unchecked, hides the tracks that are disabled on the current frame
    (except for the active track, i.e. the one that was selected last).
    This helps to make the view more clear and see if the tracking is accurate enough.

Info
:   Displays the name and status of each selected track.
    The status can be “keyframed,” “tracked,” “disabled” and so on.

3D Markers
:   Shows the result of [solving](../../../movie_clip/tracking/clip/toolbar/solve.html) the
    markers’ 3D locations based on their 2D movement. Each 3D location is projected
    back to the movie clip and displayed as a small point, which is colored green if
    it’s close to the original 2D marker (meaning a good solve) or red if it’s far away
    (meaning it needs to be tweaked).

Display Thin
:   By default, marker areas are displayed as bright boxes with a black outline.
    This option displays them using thin dashed lines instead.
user: Give a detailed overview of SpaceClipOverlay(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # SpaceClipOverlay(bpy_struct)

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

*class* bpy.types.SpaceClipOverlay(*bpy_struct*)
:   Settings for display of overlays in the Movie Clip editor

    show_cursor
    :   Display 2D cursor

        Type:
        :   boolean, default True

    show_overlays
    :   Display overlays like cursor and annotations

        Type:
        :   boolean, default True

    *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 Geometry to Instance Node: syntax, arguments, return values, common patterns.

assistant: # Geometry to Instance Node

[image reference removed]

The *Geometry to Instance* node turns every connected input geometry into an instance.
Visually, the node has a similar result as the [Join Geometry Node](join_geometry.html),
but it outputs the result as separate instances instead. The geometry data itself isn’t actually
joined.

The node can be used in combination with the *Pick Instances* option in the
[Instance on Points Node](../instances/instance_on_points.html), as a way to pick
between geometry generated in the node tree (as opposed to picking from separate
instances from the [Collection Info Node](../input/scene/collection_info.html), for example).
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Curves and [Surfaces](../surfaces/introduction.html) are particular types of Blender objects.
They are expressed by mathematical functions (interpolation)
rather than linear interpolation between a series of points.

Blender offers both [Bézier](structure.html#curve-bezier) and [NURBS](structure.html#curve-nurbs).
Both Bézier curves and NURBS curves and surfaces are defined in terms of a set of “control points”
(or “control vertices”) which define a “control polygon”.

[image reference removed]

Blender logo made from Bézier curves.

Both Bézier and NURBS curves are named after their mathematical definitions, and
choosing between them is often more a matter of how they are computed behind the scenes
than how they appear from a modeler’s perspective.
Bézier curves are generally more intuitive because they start and end at the control points that you set,
but NURBS curves are more efficient for the computer to calculate when there are many twists and turns in a curve.

The main advantage to using curves instead of polygonal meshes is that curves are defined by
less data and so can produce results using less memory and storage space at modeling time.
However, this procedural approach to surfaces can increase demands at render time.

Certain modeling techniques, such as
[extruding a profile along a path](properties/geometry.html),
are possible only using curves. On the other hand, when using curves,
vertex-level control is more difficult and if fine control is necessary,
[mesh editing](../meshes/editing/introduction.html) may be a better modeling option.

Bézier curves are the most commonly used curves for designing letters or logos.

They are also widely used in animation, both as for objects to move along (see constraints below)
and as [F-Curves](../../editors/graph_editor/fcurves/introduction.html)
to change the properties of objects as a function of time.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`IDOverrideLibrary.properties`](bpy.types.IDOverrideLibrary.html#bpy.types.IDOverrideLibrary.properties "bpy.types.IDOverrideLibrary.properties") - [`IDOverrideLibraryProperties.add`](bpy.types.IDOverrideLibraryProperties.html#bpy.types.IDOverrideLibraryProperties.add "bpy.types.IDOverrideLibraryProperties.add") | - [`IDOverrideLibraryProperties.remove`](bpy.types.IDOverrideLibraryProperties.html#bpy.types.IDOverrideLibraryProperties.remove "bpy.types.IDOverrideLibraryProperties.remove") |
user: Describe Bone Structure from the Blender manual or Python API, including usage steps and snippets.

assistant: # Bone Structure

[image reference removed]

The elements of a bone.

They have three elements:

1. The “start joint” named *root* or *head*.
2. The “body” itself.
3. And the “end joint” named *tip* or *tail*.

With the default armature in Edit Mode,
you can select the root and the tip, and move them as you do with mesh vertices.

Both root and tip (the “joints”) define the bone by their respective position.

They also have a radius property, only useful for the envelope deformation method (see below).