PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: In the first example, we overlay a grid pattern on top of two Suzanne heads after they have
been rendered. To achieve this, we enable the UV pass in the
[Property Editor](../../../editors/properties_editor.xhtml)’s
View Layer ‣ Passes panel, use it to distort the grid image,
and combine the result with the rendered image using the Alpha Over Node.

[image reference removed]

Overlaying a grid texture.

In the next example, we do the same thing with the Blender logo, using a cryptomatte
to ensure it only gets applied to one of the cubes.

It’s here that the limitations of the Map UV node become apparent: the overlaid image is
really just “plastered on” and is not affected by the lighting and shadows in the scene.
At most, you can cheat a little by making the image translucent like in the previous example.

So, while this node can be handy for certain post-production effects or fixes,
it’s generally not a replacement for including the image during rendering.

[image reference removed]

Overlaying a logo.

The third example shows how an input image can be distorted using the Map UV node, where the image UV coordinates can
be extracted from the [Image Coordinates node](../input/image_coordinates.xhtml#bpy-types-compositornodeimagecoordinates).

[image reference removed]

Procedural distortion.
user: Provide the full official documentation entry for Power of Lights, preserving all code examples.

assistant: When Normalize is enabled, the power of sun lights is specified in Watts per square meter.
The power of point lights, spot lights, and area lights is specified in Watts.

But this is not the electrical Watts that consumer light bulbs are rated at.
It is [Radiant Flux or Radiant Power](https://en.wikipedia.org/wiki/Radiant_flux) which is also measured in Watts.
It is the energy radiated from the light in the form of visible light.

If you want to set the power to real world values, you have to convert the wattage of consumer bulbs
or LED lights to radiant flux, but it is not a straightforward process.
The wattage of bulbs means the electrical power required to power them. LED lights have
a “Watt equivalent” which is neither the electrical power they require nor the amount of light they put out.
Some consumer lights specify [lumens or luminous flux](https://en.wikipedia.org/wiki/Lumen_(unit))
which is the radiant flux weighted with the wavelengths perceived by the human eye.

To save you from doing the conversion, here is a table of typical power values for point, spot, and area lights:

| Real world light | Power | Suggested Light Type |
| --- | --- | --- |
| Candle | 0.05 W | Point |
| 800 lm LED bulb | 2.1 W | Point |
| 1000 lm light bulb | 2.9 W | Point |
| 1500 lm PAR38 floodlight | 4 W | Area, Disk |
| 2500 lm fluorescent tube | 4.5 W | Area, Rectangle |
| 5000 lm car headlight | 22 W | Spot, size 125 degrees |

And a table of typical Strength values for sun lights:

| Sun type | Strength |
| --- | --- |
| Clear sky | 1000 W/m2 |
| Cloudy sky | 500 W/m2 |
| Overcast sky | 200 W/m2 |
| Moonlight | 0.001 W/m2 |

These values will produce much brighter or dimmer lights than you would expect,
because our eyes adapt while a render engine does not. So to compensate,
adjust the *Exposure* in Render ‣ Film.

To get realistic results, remember to also set the light size and color to realistic values.
The color of your lights will also influence how bright they appear to the human visual system.
If you leave the power unchanged, a green light will seem the brightest, red darker and blue the darkest.
Thus you might want to manually compensate for these perceived differences.
user: Explain Transforms to Deltas in complete detail according to the official Blender documentation.

assistant: Converts the object’s primary transforms (*Location*, *Rotation*, *Scale*) into
[Delta Transforms](../properties/transforms.html#bpy-types-object-delta).
Any existing delta transforms will be added to the new values.

This allows you to “bake” the current transforms into the delta channels, while leaving the primary
transform channels free for new adjustments or keyframes.

Available options:

- **Location to Deltas** – Converts the object’s location to *Delta Location*.
- **Rotation to Deltas** – Converts the object’s rotation to *Delta Rotation*.
- **Scale to Deltas** – Converts the object’s scale to *Delta Scale*.
- **All Transforms to Deltas** – Converts all three at once.

### Options

Reset Values
:   Clear primary transform values after transferring to deltas.

    Clears the primary transform values after transferring them to deltas.
    When enabled, the object’s main *Location*, *Rotation*, and *Scale* are reset
    (e.g. to 0 for location/rotation and 1 for scale), while the appearance remains unchanged
    because the deltas now contain the previous values.
user: Explain Scopes(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # Scopes(bpy_struct)

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

*class* bpy.types.Scopes(*bpy_struct*)
:   Scopes for statistical view of an image

    accuracy
    :   Proportion of original image source pixel lines to sample

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

    histogram
    :   Histogram for viewing image statistics

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

    use_full_resolution
    :   Sample every pixel of the image

        Type:
        :   boolean, default False

    vectorscope_alpha
    :   Opacity of the points

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

    vectorscope_mode
    :   Type:
        :   enum in [`'LUMA'`, `'RGB'`], default `'RGB'`

    waveform_alpha
    :   Opacity of the points

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

    waveform_mode
    :   Type:
        :   enum in [`'LUMA'`, `'PARADE'`, `'YCBCR601'`, `'YCBCR709'`, `'YCBCRJPG'`, `'RGB'`], default `'LUMA'`

    *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 bpy_prop_collection: syntax, arguments, return values, common patterns.

assistant: # bpy_prop_collection

*class* bpy.types.bpy_prop_collection
:   built-in class used for all collections.

    find(*key*)
    :   Returns the index of a key in a collection or -1 when not found
        (matches Python’s string find function of the same name).

        Parameters:
        :   **key** (*str*) – The identifier for the collection member.

        Returns:
        :   index of the key.

        Return type:
        :   int

    foreach_get(*attr*, *seq*)
    :   This is a function to give fast access to attributes within a collection.

        Only works for ‘basic type’ properties (bool, int and float)!
        Multi-dimensional arrays (like array of vectors) will be flattened into seq.

        ```
        collection.foreach_get(attr, some_seq)

        # Python equivalent.
        for i in range(len(seq)):
            some_seq[i] = getattr(collection[i], attr)
        ```

    foreach_set(*attr*, *seq*)
    :   This is a function to give fast access to attributes within a collection.

        Only works for ‘basic type’ properties (bool, int and float)!
        seq must be uni-dimensional, multi-dimensional arrays (like array of vectors) will be re-created from it.

        ```
        collection.foreach_set(attr, some_seq)

        # Python equivalent.
        for i in range(len(some_seq)):
            setattr(collection[i], attr, some_seq[i])
        ```

    get(*key*, *default=None*)
    :   Returns the value of the item assigned to key or default when not found
        (matches Python’s dictionary function of the same name).

        Parameters:
        :   - **key** (*str*) – The identifier for the collection member.
            - **default** (*Any*) – Optional argument for the value to return if
              *key* is not found.

    items()
    :   Return the identifiers of collection members
        (matching Python’s dict.items() functionality).

        Returns:
        :   (key, value) pairs for each member of this collection.

        Return type:
        :   list[tuple[str, [`bpy.types.bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")]]

    keys()
    :   Return the identifiers of collection members
        (matching Python’s dict.keys() functionality).

        Returns:
        :   the identifiers for each member of this collection.

        Return type:
        :   list[str]

    values()
    :   Return the values of collection
        (matching Python’s dict.values() functionality).

        Returns:
        :   The members of this collection.

        Return type:
        :   list[[`bpy.types.bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct") | None]
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Quadratic
:   Quadratic light falloff; this will leave strength unmodified if smooth is 0.0 and corresponds to reality.

Linear
:   Linear light falloff, giving a slower decrease in intensity over distance.

Constant
:   Constant light falloff, where the distance to the light has no influence on its intensity.
user: What is Common Options and how is it used in Blender Python scripting?

assistant: These options can be specified in the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel,
which appears when the object is created.
Options included in more than one primitive are:

Generate UVs
:   Generates a default UV unwrapping of new geometry.
    This will be defined in the first UV layer (which will get added if needed).

Align to View, Location, Rotation
:   See [Common Object Options](../../scene_layout/object/types.xhtml#object-common-options).
user: Explain Average Island Scale in complete detail according to the official Blender documentation.

assistant: Using the *Average Island Scale* tool, will scale each
UV island so that they are all approximately the same scale.

Non-Uniform
:   Reduces average texture stretching within islands by scaling the U and V axes independently.

Shear
:   Reduces average texture shearing within islands by shearing the U axis.
user: Provide the full official documentation entry for Interpolate, preserving all code examples.

assistant: # Interpolate

The *Interpolate* tool creates an in-between keyframe
by interpolating strokes between the previous and next Grease Pencil keyframes.
When used on a frame between two keyframes, clicking and dragging will add a new *breakdown* keyframe,
interpolating the stroke’s shape based on the drag distance.

This allows artists to manually control how strokes evolve between poses or drawings,
providing fine control over the interpolation result.
user: Explain Combine Transform Node in complete detail according to the official Blender documentation.

assistant: # Combine Transform Node

[image reference removed]

The *Combine Transform* node combines a translation vector,
a rotation vector, and a scale vector into a [Transformation Matrix](../../../../glossary/index.html#term-Transformation-Matrix).
user: Provide the full official documentation entry for Toggle Cyclic, preserving all code examples.

assistant: Opens a popover menu with the options *Cyclic U* and *Cyclic V*. The surface is made
cyclic (closed) or non-cyclic (open) in the corresponding direction.

If a surface is cyclic, the last row or column of its control point grid is connected
back to the first. A cylinder is cyclic along either the U or V direction, while
a sphere is cyclic along both.
user: Explain Spine, Head & Tail in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/addons_rigging_rigify_rig-features_spine-controls.png)

### Spine

The [spine](rig_types/spines.html#rigify-rigs-spines-basic-spine) sub-rig provides a cube shaped torso control with
switchable parent, and bent circle shaped hip and chest controls subordinate to it. For low level deformation
tweak controls are provided.

The torso control can optionally be accompanied with a custom pivot control. The rig can also optionally
provide a full set of FK controls that are subordinate to the normal simplified ones, but above tweaks.

The rig properties panel for the spine controls usually includes options for the head and/or tail as well.

[[image reference removed]](../../../_images/addons_rigging_rigify_rig-features_head-controls.png)

### Head

The [head](rig_types/spines.html#rigify-rigs-spines-super-head) sub-rig attaches to the end of the spine, and provides
rotational controls for the head and neck, as well as tweaks for fine control of the neck.

If the neck is three or more bones long, an additonal tweak-like translational
neck bend control is provided (the widget looks like a circle with arrows).

The properties panel contains the following options:

Neck Follow Slider
:   [[image reference removed]](../../../_images/addons_rigging_rigify_rig-features_head-properties.png)

    This slider controls the rotations isolation for the neck bones.
    The neck will follow the orientation of the Torso when set to 0, and the Chest when set to 1.

Head Follow Slider
:   [[image reference removed]](../../../_images/addons_rigging_rigify_rig-features_tail-controls.png)

    This slider controls the rotations isolation for the head.
    The head will follow the orientation of the Torso when set to 0, and the Chest when set to 1.

### Tail

The [tail](rig_types/spines.html#rigify-rigs-spines-basic-tail) sub-rig attaches to the start of the spine, and provides
FK controls for the tail, as well as a master control that replicates its local rotation around certain axes
to all individual bones.

The properties panel contains the following options:

Tail Follow Slider
:   This slider controls the rotations isolation for the tail.
    The tail will follow the orientation of the Torso when set to 0, and the Hips when set to 1.
user: Describe Link from the Blender manual or Python API, including usage steps and snippets.

assistant: *Link* creates a reference to data in a source file such that changes made there will be
reflected in the current file the next time it is reloaded.
In the [File Browser](../../editors/file_browser.xhtml), navigate to the external source blend-file
and select the data-blocks you want to reuse.

Linked data-blocks are indicated with a chain icon in the [Outliner](../../editors/outliner/introduction.xhtml).
They’re also listed in the Outliner’s *Blender File* [Display Mode](../../editors/outliner/interface.xhtml#bpy-types-spaceoutliner-display-mode),
along with the path of the blend-file they originate from.

Linked data-blocks are initially not editable. This even includes the location/rotation/scale
of linked objects, which are locked to the transformation they have in the source file.
There are ways around this, however:

- If you link a collection with *Instance Collections* enabled or some
  [object data](../../scene_layout/object/introduction.xhtml) with
  *Instance Object Data* enabled, the collection/object data will be referenced through
  an object created inside the current blend-file, which *can* be transformed.
  (This new object will be created at the [3D Cursor](../../editors/3dview/3d_cursor.xhtml#editors-3dview-3d-cursor).)
- You can also do some level of editing/animating on linked (and thus normally locked)
  data-blocks using [Library Overrides](library_overrides.xhtml).

### Options

These options are available in the right-hand panel of the File Browser.

Relative Path
:   Reference the external blend-file using a
    [relative path](../blend/open_save.xhtml#files-blend-relative-paths) rather than an absolute one.

Select
:   Select the newly added objects.

Active Collection
:   When enabled, objects and collections will be added to the active collection of the active
    [view layer](../../render/layers/introduction.xhtml).
    Otherwise, they will be added to a new “Linked Data” collection in the active view layer.

Instance Collections
:   When enabled, each linked collection will be added to the scene as an
    [instance collection](../../scene_layout/object/properties/instancing/collection.xhtml)
    (that is, a single object that represents the entire collection).
    You can add more such instances using Add ‣ Collection Instance,
    or replace an instance by the collection contents using [Make Instances Real](../../scene_layout/object/editing/apply.xhtml#bpy-ops-object-duplicates-make-real).

    When disabled, the collections will be added as-is so you can see their content in the
    Outliner and create Library Overrides.

Instance Object Data
:   When enabled, an object will be created for each directly linked object data.
    Otherwise, no object will be created and the object data will not be visible in
    the scene until you create one yourself (e.g. by dragging the object data from the
    Outliner into the 3D Viewport).
user: Show practical ways to work with Transform in a Blender add-on or script – include code.

assistant: A curves objects can be edited by transforming the locations of control points.

Move, Rotate, Scale
:   Like other elements in Blender, control points can be moved, rotated, or scaled as described in
    [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.html).

To Sphere, Shear, Bend, Push/Pull
:   The transform tools are described in
    the [Transformations](../../meshes/editing/mesh/transform/index.html) sections.

### Radius

The Radius allows you to directly control the width of the extrusion along the “spinal” curve.
The radius will be interpolated from point to point (you can check it with the normals).
The *Radius* of the points is set using the *Radius* transform tool. Or in the Sidebar *Transform* panel.

[[image reference removed]](../../../_images/modeling_curves_editing_curve_extrude-radius.png)

One control point radius set to zero.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`FreestyleLineStyle.thickness_modifiers`](bpy.types.FreestyleLineStyle.html#bpy.types.FreestyleLineStyle.thickness_modifiers "bpy.types.FreestyleLineStyle.thickness_modifiers") |  |
user: Provide the full official documentation entry for MaskLayer(bpy_struct), preserving all code examples.

assistant: # MaskLayer(bpy_struct)

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

*class* bpy.types.MaskLayer(*bpy_struct*)
:   Single layer used for masking pixels

    alpha
    :   Render Opacity

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

    blend
    :   Method of blending mask layers

        Type:
        :   enum in [`'MERGE_ADD'`, `'MERGE_SUBTRACT'`, `'ADD'`, `'SUBTRACT'`, `'LIGHTEN'`, `'DARKEN'`, `'MUL'`, `'REPLACE'`, `'DIFFERENCE'`], default `'ADD'`

    falloff
    :   Falloff type of the feather

        Type:
        :   enum in [Proportional Falloff Curve Only Items](bpy_types_enum_items/proportional_falloff_curve_only_items.html#rna-enum-proportional-falloff-curve-only-items), default `'SMOOTH'`

    hide
    :   Restrict visibility in the viewport

        Type:
        :   boolean, default False

    hide_render
    :   Restrict renderability

        Type:
        :   boolean, default False

    hide_select
    :   Restrict selection in the viewport

        Type:
        :   boolean, default False

    invert
    :   Invert the mask black/white

        Type:
        :   boolean, default False

    name
    :   Unique name of layer

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

    select
    :   Layer is selected for editing in the Dope Sheet

        Type:
        :   boolean, default False

    splines
    :   Collection of splines which defines this layer

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

    use_fill_holes
    :   Calculate holes when filling overlapping curves

        Type:
        :   boolean, default False

    use_fill_overlap
    :   Calculate self intersections and overlap before filling

        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: Give a detailed overview of Marker Menu: syntax, arguments, return values, common patterns.

assistant: [Markers](../../animation/markers.xhtml) are used to denote frames with key points or significant events
within an animation. Like with most animation editors, they’re shown at the bottom.

[image reference removed]

Markers in animation editor.

There are some options that are exclusive to the Dope Sheet editor:

Sync Markers
:   Whether to also move the selected markers when moving the selected keyframes.

Show Pose Markers Action Editor
:   Instead of showing the global scene markers, show the local pose markers (which only exist inside the action).
    While this option is active, the *Add Marker* menu item will also create pose markers instead of scene markers.

Make Markers Local Action Editor
:   Converts the selected scene markers into pose markers,
    making them only visible inside the currently selected action.

For information about the other marker tools, see [Editing Markers](../../animation/markers.xhtml#animation-markers-editing).
user: Describe Touchpad from the Blender manual or Python API, including usage steps and snippets.

assistant: Multi-touch Gestures
:   Use multi-touch gestures for navigation with touchpad, instead of scroll wheel emulation.
    For more detail on supported gestures,
    see [Configuring Peripherals](../../getting_started/configuration/hardware.xhtml).

Scroll Direction
:   The direction scrolling responds to the scroll gestures.

    Only available on Linux using Wayland.

    Traditional:
    :   Scrolls content down when gestures move up.

    Natural:
    :   Scrolls content up when gestures move up.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Data Type
:   The [data type](../../attributes_reference.xhtml#attribute-data-types) used for the evaluated data.

Mode
:   How to find endpoint positions for the trimmed spline.
    The option acts the same as it does in the [Trim Curve Node](../operations/trim_curve.xhtml).

    Factor:
    :   Find the endpoint positions using a factor of each spline’s length.
        The input values should be between 0 or 1.

    Length:
    :   Find the endpoint positions using a length from the start of each spline.
        The input values should be between 0 and the length of the splines.

All Curves
:   Sample lengths based on the total length of all curves, rather than using a length inside each selected curve.
user: Provide the full official documentation entry for NodeClosureOutputItem(bpy_struct), preserving all code examples.

assistant: # NodeClosureOutputItem(bpy_struct)

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

*class* bpy.types.NodeClosureOutputItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

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

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

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

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

assistant: Bones can be classified into two types depending on their
[Deform](properties/deform.xhtml) setting:

### Deforming Bones

Bones that have the *Deform* setting enabled will drag vertices along with them.
For example, you could have a bone in a character’s upper arm and another in
the lower arm, and then rotate and flex the arm by transforming these bones.

### Control Bones

Bones that have the *Deform* setting disabled do not drag any vertices along.
Instead, they’re typically used to control other bones.

A common use case is
[inverse kinematics](../posing/bone_constraints/inverse_kinematics/introduction.xhtml):
rotating the above two arm bones manually is a bit of a pain, so instead,
you can add a control bone and configure the arm bones to automatically orient
themselves towards it. This way, you can simply position the control bone
where the character’s hand should be, which is much easier.
user: Provide the full official documentation entry for Faces, preserving all code examples.

assistant: # Faces

*Instancing Faces* is the capability to replicate an object on each face of a parent object.
One of the best ways to explain this is through an example illustration.

Scale
:   Scales each instance according to the size of its corresponding face.

    Inherit Scale
    :   Scale the instance faces objects.

*Make Instance Face* tool converts linked objects (that share mesh data) into instanced faces.
This tool creates the parent object (instancer) with faces where the objects were,
then it uses *Instancing Faces* to put instances at the location of every created face.

You can go back from *Instancing Faces* to multiple linked objects using
[Make Instances Real](../../editing/apply.xhtml#bpy-ops-object-duplicates-make-real).
user: Provide the full official documentation entry for Polygonization, preserving all code examples.

assistant: # Polygonization

The *Polygonization* modifier simplifies strokes as much as possible
(in other words, it transforms smooth strokes into jagged polylines).

Error
:   The maximum distance allowed between the new simplified stroke and the original one
    (the larger this value is, the more jagged/approximated the resulting polylines are).
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`ArmatureConstraint.targets`](bpy.types.ArmatureConstraint.html#bpy.types.ArmatureConstraint.targets "bpy.types.ArmatureConstraint.targets") - [`ArmatureConstraintTargets.new`](bpy.types.ArmatureConstraintTargets.html#bpy.types.ArmatureConstraintTargets.new "bpy.types.ArmatureConstraintTargets.new") | - [`ArmatureConstraintTargets.remove`](bpy.types.ArmatureConstraintTargets.html#bpy.types.ArmatureConstraintTargets.remove "bpy.types.ArmatureConstraintTargets.remove") |
user: What is SpreadsheetTableIDGeometry(SpreadsheetTableID) and how is it used in Blender Python scripting?

assistant: # SpreadsheetTableIDGeometry(SpreadsheetTableID)

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

*class* bpy.types.SpreadsheetTableIDGeometry(*SpreadsheetTableID*)
:   attribute_domain
    :   Attribute domain to display

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

    geometry_component_type
    :   Part of the geometry to display data from

        Type:
        :   enum in [Geometry Component Type Items](bpy_types_enum_items/geometry_component_type_items.html#rna-enum-geometry-component-type-items), default `'MESH'`, (readonly)

    layer_index
    :   Index of the Grease Pencil layer

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    object_eval_state
    :   - `EVALUATED`
          Evaluated – Use data from fully or partially evaluated object.
        - `ORIGINAL`
          Original – Use data from original object without any modifiers applied.
        - `VIEWER_NODE`
          Viewer Node – Use intermediate data from viewer node.

        Type:
        :   enum in [`'EVALUATED'`, `'ORIGINAL'`, `'VIEWER_NODE'`], default `'EVALUATED'`, (readonly)

    viewer_path
    :   Path to the data that is displayed

        Type:
        :   [`ViewerPath`](bpy.types.ViewerPath.html#bpy.types.ViewerPath "bpy.types.ViewerPath"), (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: Give a detailed overview of Areas: syntax, arguments, return values, common patterns.

assistant: # Areas

[[image reference removed]](../../_images/interface_window-system_areas_borders.png)

Area boundaries are indicated by rounded corners (yellow highlights).

The Blender window is divided into a number of rectangles called Areas.
Areas reserve screen space for [Editors](../../editors/index.html), such as the
[3D Viewport](../../editors/3dview/introduction.html) or the
[Outliner](../../editors/outliner/introduction.html).
Each editor offers a specific piece of functionality.

Areas are grouped into [Workspaces](workspaces.html),
which are geared towards particular tasks (modeling, animating and so on).
user: Show practical ways to work with GeometryNodeCurvePrimitiveQuadrilateral(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeCurvePrimitiveQuadrilateral(GeometryNode)

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

*class* bpy.types.GeometryNodeCurvePrimitiveQuadrilateral(*GeometryNode*)
:   Generate a polygon with four points

    mode
    :   - `RECTANGLE`
          Rectangle – Create a rectangle.
        - `PARALLELOGRAM`
          Parallelogram – Create a parallelogram.
        - `TRAPEZOID`
          Trapezoid – Create a trapezoid.
        - `KITE`
          Kite – Create a Kite / Dart.
        - `POINTS`
          Points – Create a quadrilateral from four points.

        Type:
        :   enum in [`'RECTANGLE'`, `'PARALLELOGRAM'`, `'TRAPEZOID'`, `'KITE'`, `'POINTS'`], default `'RECTANGLE'`

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

assistant: # GeometryNodeInputMaterialIndex(GeometryNode)

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

*class* bpy.types.GeometryNodeInputMaterialIndex(*GeometryNode*)
:   Retrieve the index of the material used for each element in the geometry’s list of materials

    *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: Describe GeometryNodePointsToCurves(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodePointsToCurves(GeometryNode)

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

*class* bpy.types.GeometryNodePointsToCurves(*GeometryNode*)
:   Split all points to curve by its group ID and reorder by weight

    *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: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Segment Coordinates
:   Segment coordinates for texture mapping within each radial segment.

Segment ID
:   Unique ID for every radial segment startiing at 0 and increasing counterclockwise by 1 for every for each segment.

Segment Width
:   Relative width of each radial segment. May be used to scale textures to fit into each segment.

Segment Rotation
:   Counterclockwise rotation of each segment coordinate system. May be used to align the rotation of the textures of each segment.
user: What is Video Sequencer and how is it used in Blender Python scripting?

assistant: Memory Cache Limit
:   Upper limit of the Video Sequencer and Movie Clip Editor memory cache (in megabytes).
    For an optimal Clip editor and Sequencer performance, high values are recommended.

Proxy Setup
:   When and how [Proxies](../video_sequencer/sequencer/sidebar/proxy.xhtml) are created.

    Automatic:
    :   Build proxies for added movie and image strips in each preview size.

    Manual:
    :   Set up proxies manually.
user: What is Make Planar Faces and how is it used in Blender Python scripting?

assistant: Flattens the selected faces.

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

Iterations
:   Number of times to repeat the operation.
user: Give a detailed overview of Bpy.Types.Vertexweighteditmodifier: syntax, arguments, return values, common patterns.

assistant: Modifier.mask_constant VertexWeightEditModifier.mask_tex_map_bone VertexWeightEditModifier.mask_tex_map_object VertexWeightEditModifier.mask_tex_mapping VertexWeightEditModifier.mask_tex_use_channel VertexWeightEditModifier.mask_tex_uv_layer VertexWeightEditModifier.mask_texture VertexWeightEditModifier.mask_vertex_group VertexWeightEditModifier.normalize VertexWeightEditModifier.remove_threshold VertexWeightEditModifier.use_add VertexWeightEditModifier.use_remove VertexWeightEditModifier.vertex_group VertexWeightEditModifier.bl_rna_get_subclass() VertexWeightEditModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Enabling Add-on in a Blender add-on or script – include code.

assistant: This add-on is enabled by default, in case it is not:

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

assistant: Grid
:   The input voxel grid to convert into a mesh.
    The grid must store float values such as those from a signed distance or density field.

Threshold
:   The value that defines the surface of the generated mesh.
    Voxels with values larger than this threshold are considered *inside* the
    mesh, while smaller values are considered *outside*.
    For SDF grids, a threshold of `0.0` typically corresponds to the surface.

Adaptivity
:   Controls the simplification of the generated mesh based on curvature.
    Higher values reduce polygon count by merging nearly flat areas, while
    smaller values preserve more detail.
    A value of `0.0` disables adaptivity and produces a uniform mesh density.
user: How do I use Chroma Vectorscope in Blender? Include parameters, examples, warnings and best practices.

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

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

|  |  |
| --- | --- |
| ../../../../_images/video-editing_preview_display-mode_example.jpg   Example image. | ../../../../_images/video-editing_preview_display-mode_vectorscope.png   Corresponding Chroma Vectorscope. |
user: What is Roll and how is it used in Blender Python scripting?

assistant: Rotate the viewport camera around its viewing direction in 15° discrete steps by default.
See the [rotation angle](../../preferences/navigation.html#bpy-types-preferencesview-rotation-angle) preference to configure.

To reset the roll, you can first align the view to the global X axis
using `Numpad3`, then orbit to get back to the regular perspective view.

`RMB` cancels the roll operation.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: Scale X, Y, Z
:   The amount to resize the selection on their respected axis.

Orientation
:   Aligns the transformation axes to a specified orientation constraint.
    See [Transform Orientations](../../../editors/3dview/controls/orientation.xhtml) for more information.

Proportional Editing
:   The extruded face will affect nearby geometry.
    See [Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml) for a full reference.
user: Provide the full official documentation entry for Physical Properties, preserving all code examples.

assistant: # Physical Properties

Vertex Mass
:   The mass of the cloth material.

Air Viscosity
:   Air has some thickness which slows falling things down.

Bending Model
:   Linear:
    :   Cloth model with linear bending springs (old).

    Angular:
    :   Cloth model with angular bending springs.
user: Provide the full official documentation entry for Reducing Noise, preserving all code examples.

assistant: # Reducing Noise

When performing a final render, it is important to reduce noise as much as possible.
Here we will discuss a number of tricks that, while breaking the laws of physics,
are particularly important when rendering animations within a reasonable time.
Click to enlarge the example images to see the noise differences well.
user: Give a detailed overview of Vignette Node: syntax, arguments, return values, common patterns.

assistant: # Vignette Node

[image reference removed]

The *Vignette* node darkens or fades out the edges of an image to draw attention toward the center.
This effect is often used for artistic or cinematic purposes to create focus, mood, or a sense of depth.
user: Give a detailed overview of Light Path Node: syntax, arguments, return values, common patterns.

assistant: # Light Path Node

[image reference removed]

The *Light Path* node is used to find out for which kind of incoming ray the shader is being executed;
particularly useful for non-physically-based tricks. More information about the meaning of each type
is in the [Light Paths](../../cycles/render_settings/light_paths.xhtml) documentation.
user: Describe Type from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender has five types of metas, each determined by its underlying (or directing) structure.

In Edit Mode, you can change this structure,
either using the relevant buttons in the *Active Element* panel,
or the selector in the *Transform* panel in the Sidebar region.
Depending on the structure, you might have additional parameters,
located in both *Transform* panel and *Active Element* panel.

Ball (point, zero-dimensional structure)
:   This is the simplest meta, without any additional setting. As it is just a point,
    it generates an isotropic field, yielding a spherical surface
    (this is why it is called *Meta Ball* or *Ball* in Blender).

Capsule (straight line, one-dimensional structure)
:   This is a meta which surface is generated by the field produced by a straight line of a given length.
    This gives a cylindrical surface, with rounded closed ends.

    Size X
    :   The length of the line (and hence, of the capsule).

Plane (rectangular plane, two-dimensional structure)
:   This is a meta which surface is generated by the field produced by a rectangular plane.
    This gives a parallelepipedal surface, with a fixed thickness, and rounded borders.

    Size X/Y
    :   The length and width of the rectangle.

Ellipsoid (ellipsoidal volume, three-dimensional structure)
:   This is a meta which surface is generated by the field produced by an ellipsoidal volume.
    This gives an ellipsoidal surface.

    Size X/Y/Z
    :   The length, width and height of the ellipsoid.

Cube (parallelepipedal volume, three-dimensional structure)
:   This is a meta which surface is generated by the field produced by a parallelepipedal volume.
    This gives a parallelepipedal surface, with rounded edges.

    Size X/Y/Z
    :   The length, width and height of the parallelepiped.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy.context.edit_text`](bpy.context.html#bpy.context.edit_text "bpy.context.edit_text") - [`BlendData.texts`](bpy.types.BlendData.html#bpy.types.BlendData.texts "bpy.types.BlendData.texts") - [`BlendDataTexts.load`](bpy.types.BlendDataTexts.html#bpy.types.BlendDataTexts.load "bpy.types.BlendDataTexts.load") - [`BlendDataTexts.new`](bpy.types.BlendDataTexts.html#bpy.types.BlendDataTexts.new "bpy.types.BlendDataTexts.new") - [`BlendDataTexts.remove`](bpy.types.BlendDataTexts.html#bpy.types.BlendDataTexts.remove "bpy.types.BlendDataTexts.remove") - [`Camera.custom_shader`](bpy.types.Camera.html#bpy.types.Camera.custom_shader "bpy.types.Camera.custom_shader") | - [`FreestyleModuleSettings.script`](bpy.types.FreestyleModuleSettings.html#bpy.types.FreestyleModuleSettings.script "bpy.types.FreestyleModuleSettings.script") - [`NodeFrame.text`](bpy.types.NodeFrame.html#bpy.types.NodeFrame.text "bpy.types.NodeFrame.text") - [`ShaderNodeScript.script`](bpy.types.ShaderNodeScript.html#bpy.types.ShaderNodeScript.script "bpy.types.ShaderNodeScript.script") - [`ShaderNodeTexIES.ies`](bpy.types.ShaderNodeTexIES.html#bpy.types.ShaderNodeTexIES.ies "bpy.types.ShaderNodeTexIES.ies") - [`SpaceTextEditor.text`](bpy.types.SpaceTextEditor.html#bpy.types.SpaceTextEditor.text "bpy.types.SpaceTextEditor.text") |