PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Input Nodes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Input Nodes

Input nodes produce information from a data source.
For instance, an input can be:

- Taken directly from the active camera in a selected scene.
- A static image.
- A movie clip (such as an image sequence or video).
- A color or value.

These nodes generate the information that is passed to other nodes.
As such, they have no input sockets; only outputs.

---

---
user: What is Select Linked and how is it used in Blender Python scripting?

assistant: Selects all the bones in the chain which the active (last selected) bone belongs to.

All Forks
:   Selects all bones connected to the active bone even if the branch off from the current bone.

Linked bones selection.

|  |  |
| --- | --- |
| <../../../_images/animation_armatures_bones_selecting_single-bone.png>   A single selected bone. | <../../../_images/animation_armatures_bones_selecting_whole-chain.png>   Its whole chain selected with Linked. |
user: Give a detailed overview of Color Strip: syntax, arguments, return values, common patterns.

assistant: # Color Strip

This effect generates solid color frames.
By default, when it is created, the Color strip is 25 frames long, but
you can extend it by selecting and moving one of the ends.
Use this strip crossed with your main movie to provide a fade-in or fade-out.
user: Describe Clean Vertex Group Weights from the Blender manual or Python API, including usage steps and snippets.

assistant: Clean Vertex Group Weights unassigns vertices from
[Vertex Groups](../../../modeling/meshes/properties/vertex_groups/index.xhtml)
whose weights are below the *Limit*. Removes weights below a given threshold.
This tool is useful for clearing your weight groups of very low (or zero) weights.

In the example shown, a cutoff value of 0.2 is used (see operator options below)
so all blue parts are cleaned out.

Note, the images use the *Show Zero weights* Active option
so that unreferenced Weights are shown in Black.

[image reference removed]

Clean example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](../../../sculpt_paint/weight_paint/editing.xhtml#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   This is the minimum weight value that will be kept in the group.
    Weights below this value will be removed from the group.

Keep Single
:   Ensure that the *Clean Vertex Group Weights* tool will not create completely unreferenced vertices
    (which are vertices that are not assigned to any vertex group), so each vertex will
    keep at least one weight, even if it is below the limit value!
user: Give a detailed overview of Color Attributes: syntax, arguments, return values, common patterns.

assistant: Color data can be applied directly to an object’s vertices rather than using a texture or a material.
There are two modes to paint color attributes in.
Use [Vertex Paint](../../../sculpt_paint/vertex_paint/index.html) mode to paint per face corner
by enabling the paint mask in the header.
This is useful to achieve sharp edges in the color attribute on low-poly assets.
Alternatively use Sculpt mode to paint on a much higher vertex count.

### Creating a New Color Attribute

To create a new Color Attribute select the plus icon next to the list of attributes.
This action will open a pop-up with the following information.

Name
:   The name of the Color Attribute which can be referenced elsewhere in Blender.

Domain
:   The associated part of the geometry that stores the attribute.
    See [Attribute Domains](../../geometry_nodes/attributes_reference.html#attribute-domains) for more information.

    Vertex:
    :   Color Attributes are stored per each vertex.

    Face Corner:
    :   Color Attributes are stored per each corner of a face.

Data Type
:   The data type to represent colors internally.

    Color:
    :   RGBA color with floating-point precision.

    Byte Color:
    :   RGBA color with 8-bit precision.

Color
:   The default color to fill for every element in the domain.

### Color Attribute Specials

These are operators that are available in the menu to the right of the attribute list.

Duplicate Color Attribute
:   Creates a copy of the active color attribute in the list.

Convert Color Attribute
:   Changes how the color attribute is stored.

    Domain
    :   The associated part of the geometry that stores the attribute.
        See [Attribute Domains](../../geometry_nodes/attributes_reference.html#attribute-domains) for more information.

        Vertex:
        :   Color Attributes are stored per each vertex.

        Face Corner:
        :   Color Attributes are stored per each corner of a face.

    Data Type
    :   The data type to represent colors internally.

        Color:
        :   RGBA color with floating-point precision.

        Byte Color:
        :   RGBA color with 8-bit precision.
user: Show practical ways to work with Checker Deselect in a Blender add-on or script – include code.

assistant: # Checker Deselect

This tool applies an alternating selected/deselected checker pattern.
This only works if you already have more than one mesh element selected.

Changes the current selection so that only every Nth elements (vertices, edges or faces,
depending on the active selection mode) will remain selected, starting from the active one.

In case of islands of selected elements, this tool will affect
only the island of the active element (if there is one), or the island of the first element
in the order of internal storage (if there is no active element).

Deselected
:   The number of deselected elements in each pattern repetition.

Selected
:   The number of selected elements in each pattern repetition.

Offset
:   Offset from the starting point.
user: How do I use SCENE_UL_keying_set_paths(UIList) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SCENE_UL_keying_set_paths(UIList)

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

*class* bpy.types.SCENE_UL_keying_set_paths(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

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

assistant: The *Glare* node provides an interactive gizmo in the Node Editor.
To use it, enable [Active Node Gizmo](../../../editors/compositor.html#bpy-types-spacenodeeditor-show-gizmo-active-node) and
select the *Glare* node.

For the *Sun Beams* type, a cross-shaped gizmo appears in the image preview to set the *Sun Position*.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Dimensions
:   The dimensions of the space to evaluate the noise in.

    1D:
    :   Evaluate the noise in 1D space at the input *W*.

    2D:
    :   Evaluate the noise in 2D space at the input *Vector*. The Z component is ignored.

    3D:
    :   Evaluate the noise in 3D space at the input *Vector*.

    4D:
    :   Evaluate the noise in 4D space at the input *Vector* and the input *W* as the fourth dimension.

Type
:   Type of Noise texture, with different ways to combine octaves.

    fBM:
    :   Fractal Brownian motion, produces a homogeneous and isotropic result.
        Values from octaves are added together.

    Multifractal:
    :   More uneven, varying by location similar to real terrain.
        Values from octaves are multiplied together.

    Hybrid Multifractal:
    :   Creates peaks and valleys with different roughness values, like real mountains rise out of flat plains.
        Combines octaves using both addition and multiplication.

    Ridged Multifractal:
    :   Creates sharp peaks. Calculates the absolute value of the noise,
        creating “canyons”, and then flips the surface upside down.

    Hetero Terrain:
    :   Similar to *Hybrid Multifractal* creates a heterogeneous terrain, but with the likeness of river channels.

Normalize fBM
:   If enabled, ensures that the output values stay in the range 0.0 to 1.0.
    If disabled, the range is at most -(*Detail* + 1) to *Detail* + 1 (smaller if *Roughness* < 1).
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Bones and Vertex Groups

This video shows the effect of the *Head/Tail* setting when targeting a bone,
as well as the *Vertex Group* setting when targeting a mesh.

### Solar System

In the animation below, the camera follows the moon as it orbits the Earth,
switches to following the Earth as it orbits the Sun, and finally moves to a fixed
location for showing the Sun. This is done using two *Copy Location* constraints –
one for the moon and one for the Earth – with animated *Influence* values for
smoothly disabling one while enabling the other.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation to rotate.

Rotate By
:   Specifies how much an Euler rotation is rotated. This input is only available
    when the rotation type is set to *Euler*.

Axis
:   The axis to rotate around. This input is only available when the rotation type is set to *Axis Angle*.

Angle
:   The angle to rotate by around the specified axis. This input is only available
    when the rotation type is set to *Axis Angle*.
user: Describe Assigning to Existing Classes from the Blender manual or Python API, including usage steps and snippets.

assistant: Custom properties can be added to any subclass of an `ID`,
`Bone` and `PoseBone`.

These properties can be animated, accessed by the user interface and Python
like Blender’s existing properties.

```
import bpy

# Assign a custom property to an existing type.
bpy.types.Material.custom_float = bpy.props.FloatProperty(name="Test Property")

# Test the property is there.
bpy.data.materials[0].custom_float = 5.0
```
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Resolution
:   Number of points in one rotation of the spiral.

Rotations
:   Number of times the spiral makes a full rotation.

Start Radius, End Radius
:   Radius of the start point and end point of the spiral.
    The radius of the spiral changes linearly between the two values over the whole spiral.

Height
:   Height of the spiral.

Reverse
:   Boolean value that changes the direction from clockwise to counterclockwise when it is enabled.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`KeyingSetInfo.generate`](bpy.types.KeyingSetInfo.html#bpy.types.KeyingSetInfo.generate "bpy.types.KeyingSetInfo.generate") - [`KeyingSetInfo.iterator`](bpy.types.KeyingSetInfo.html#bpy.types.KeyingSetInfo.iterator "bpy.types.KeyingSetInfo.iterator") - [`KeyingSets.active`](bpy.types.KeyingSets.html#bpy.types.KeyingSets.active "bpy.types.KeyingSets.active") - [`KeyingSets.new`](bpy.types.KeyingSets.html#bpy.types.KeyingSets.new "bpy.types.KeyingSets.new") | - [`KeyingSetsAll.active`](bpy.types.KeyingSetsAll.html#bpy.types.KeyingSetsAll.active "bpy.types.KeyingSetsAll.active") - [`Scene.keying_sets`](bpy.types.Scene.html#bpy.types.Scene.keying_sets "bpy.types.Scene.keying_sets") - [`Scene.keying_sets_all`](bpy.types.Scene.html#bpy.types.Scene.keying_sets_all "bpy.types.Scene.keying_sets_all") |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field that is true for parts of the geometry to be deleted.

Amount
:   Field indicating how many times each input element should be duplicated.
    If the value is zero for an element, it will not be included in the output at all.
user: How do I use AOV(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # AOV(bpy_struct)

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

*class* bpy.types.AOV(*bpy_struct*)
:   is_valid
    :   Is the name of the AOV conflicting

        Type:
        :   boolean, default False

    name
    :   Name of the AOV

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

    type
    :   Data type of the AOV

        Type:
        :   enum in [`'COLOR'`, `'VALUE'`], default `'COLOR'`

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.AOV.type "bpy.types.AOV.type")
user: Show practical ways to work with 403 Error Accessing Extensions in a Blender add-on or script – include code.

assistant: On systems or networks that use an additional layer of SSL management:
it’s possible Blender’s connection to `https://extensions.blender.org` is blocked.

In this case the problem can’t be resolved in Blender’s side,
it’s up the system administrators to allow a connection to `extensions.blender.org`.

See: [this report](https://projects.blender.org/blender/blender/issues/129681).
user: Give a detailed overview of Controls: syntax, arguments, return values, common patterns.

assistant: You can select and create scenes with the *Scene* data-block menu in the
[Topbar](../../interface/window_system/topbar.xhtml).

[image reference removed]

Scene data-block menu.

Scenes
:   A list of available scenes in the current blend-file.

Add
:   New
    :   Creates an empty scene with default values.

    Copy Settings
    :   Creates an empty scene but copies render and world settings from the active scene.

    Linked Copy
    :   Creates a new scene that shares all data with the current one.
        The new scene contains links to the same collections, objects, and data-blocks as the original.
        Changes made in one scene automatically affect the other, since they reference the same data.

    Full Copy
    :   Creates a fully independent scene with unique copies of all objects and their data.
        This is useful for variations or alternate versions of a scene that should not affect the original.

(Delete Scene)
:   Deletes the current scene data-block.
    Note that Blender always requires at least one scene in a file; you cannot delete the last remaining one.
user: Explain FCurveKeyframePoints(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # FCurveKeyframePoints(bpy_struct)

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

*class* bpy.types.FCurveKeyframePoints(*bpy_struct*)
:   Collection of keyframe points

    insert(*frame*, *value*, *\**, *options={}*, *keyframe_type='KEYFRAME'*)
    :   Add a keyframe point to a F-Curve

        Parameters:
        :   - **frame** (*float in* *[**-inf**,* *inf**]*) – X Value of this keyframe point
            - **value** (*float in* *[**-inf**,* *inf**]*) – Y Value of this keyframe point
            - **options** (enum set in {`'REPLACE'`, `'NEEDED'`, `'FAST'`}, (optional)) –

              Keyframe options

              - `REPLACE`
                Replace – Don’t add any new keyframes, but just replace existing ones.
              - `NEEDED`
                Needed – Only adds keyframes that are needed.
              - `FAST`
                Fast – Fast keyframe insertion to avoid recalculating the curve each time.
            - **keyframe_type** (enum in [Beztriple Keyframe Type Items](bpy_types_enum_items/beztriple_keyframe_type_items.html#rna-enum-beztriple-keyframe-type-items), (optional)) – Type of keyframe to insert

        Returns:
        :   Newly created keyframe

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

    add(*count*)
    :   Add a keyframe point to a F-Curve

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Number, Number of points to add to the spline

    remove(*keyframe*, *\**, *fast=False*)
    :   Remove keyframe from an F-Curve

        Parameters:
        :   - **keyframe** ([`Keyframe`](bpy.types.Keyframe.html#bpy.types.Keyframe "bpy.types.Keyframe"), (never None)) – Keyframe to remove
            - **fast** (*boolean**,* *(**optional**)*) – Fast, Fast keyframe removal to avoid recalculating the curve each time

    clear()
    :   Remove all keyframes from an F-Curve

    sort()
    :   Ensure all keyframe points are chronologically sorted

    deduplicate()
    :   Ensure there are no duplicate keys. Assumes that the points have already been sorted

    handles_recalc()
    :   Update handles after modifications to the keyframe points, to update things like auto-clamping

    *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 Toolbar in Blender? Include parameters, examples, warnings and best practices.

assistant: # Toolbar

Curve Edit Mode tools:

[Select](../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or move.

    [Select Box](../../../interface/selecting.xhtml#tool-select-box)
    :   Select objects by dragging a box.

        All objects that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.xhtml#tool-select-circle)
    :   Select objects by dragging a circle. All objects that intersect the path of
        the circle will be selected.

    [Select Lasso](../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select objects by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

[Draw](draw.xhtml#bpy-ops-curve-draw)
:   Free-hand drawing of new curves.

[Curve Pen](pen.xhtml#bpy-ops-curve-pen)
:   Construct and edit splines.

[Extrude](../editing/control_points.xhtml#modeling-curves-extrude)
:   Extrude the curve by adding new control points.

[Radius](../editing/curve.xhtml#modeling-curve-radius)
:   Control the radius value of the control points.

[Tilt](../editing/control_points.xhtml#modeling-curve-tilt)
:   Control the rotation value of the control points around the curve’s axis.

Randomize
:   Move selected control points in pseudo-random directions.
user: What is Alpha Over & Alpha Under Strips and how is it used in Blender Python scripting?

assistant: # Alpha Over & Alpha Under Strips

Using the alpha (transparency channel),
this effect composites a result based on transparent areas of the dominant image.
If you use a Scene strip, the areas of the image where there is not anything solid are transparent;
they have an alpha value of 0. If you use a Movie strip, that movie has an alpha value of 1 (completely opaque).

So, you can use the *Alpha Over* / *Alpha Under* effect to composite the CGI Scene on top of your movie.
The result is your model doing whatever as if it was part of the movie.
The Adjust ‣ Compositing ‣ Opacity controls how much
the foreground is mixed over the background, fading in the foreground on top of the background.
The colors of transparent foreground image areas are ignored and do not change the color of the background.
user: Show practical ways to work with Grease Pencil in a Blender add-on or script – include code.

assistant: Playback Only
:   Activates the simplification process only during animation playback.

Fill
:   Shows the fill component in Grease Pencil materials.

Modifiers
:   Shows Grease Pencil [modifiers](../../../grease_pencil/modifiers/index.html).

Shader Effects
:   Shows Grease Pencil [visual effects](../../../grease_pencil/modifiers/index.html).

Layer Tinting
:   Shows layers tint overrides.

Anti-Aliasing
:   Use [Anti-Aliasing](../../../glossary/index.html#term-Anti-Aliasing) to smooth stroke edges. The amount of anti-aliasing can be adjusted by
    the [SMAA Threshold](grease_pencil.html#bpy-types-scenegpencil-antialias-threshold).
user: Describe LineStyleAlphaModifier_Tangent(LineStyleAlphaModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleAlphaModifier_Tangent(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_Tangent(*LineStyleAlphaModifier*)
:   Alpha transparency based on the direction of the stroke

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleAlphaModifier_Tangent.type "bpy.types.LineStyleAlphaModifier_Tangent.type")
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Copy Scale constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone whose scale to copy.

Axis
:   The axes for which to copy scale factors.

Power
:   Raises the target’s scales to the specified power. This is done before applying
    the *Offset*.

Make Uniform
:   Instead of applying the scale for each individual axis, apply a uniform scale
    to all axes that achieves the same overall change in volume.

Offset
:   When enabled, the target’s current scale (from all its constraints) is not
    copied over, but multiplied with the owner’s original scale
    (from its preceding constraints).

Additive
:   When *Offset* is enabled, don’t use multiplication, but add the owner’s scales minus 1.
    This option is kept for backwards compatibility, but generally makes no sense and should not be used.

[Target/Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The spaces for retrieving the scales from the target and for applying them to the owner.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Describe Color Filter from the Blender manual or Python API, including usage steps and snippets.

assistant: # Color Filter

Apply color corrections or effects on the active color attribute
on all vertices in the mesh at the same time.

To use this tool, click and drag away from left to right
or from right to left for a negative effect.
user: Give a detailed overview of Select Linked: syntax, arguments, return values, common patterns.

assistant: Press `Ctrl`-`L` to select all control points that are “linked to” (belong to the same
surface as) a control point that’s already selected.

Alternatively, press `L` to select the control point under the mouse cursor and all
control points that are linked to it.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: ### General

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

Usually, an [Image Texture node](../../../render/shader_nodes/textures/image.xhtml) mapped to the UV map
that the modifier targets is added to the object’s material.
user: Explain Code Examples in complete detail according to the official Blender documentation.

assistant: Here is an example of threading supported by Blender:

```
import threading
import requests

urls = [
   "http://localhost:8000/file-1.blend",
   "http://localhost:8000/file-2.blend",
   "http://localhost:8000/file-3.blend",
]

def download(url: str) -> None:
   name = threading.current_thread().name
   print("{}: Starting".format(name))
   response = requests.get(url)
   print("{}: Request status code {}".format(name, response.status_code))

threads = [
   threading.Thread(
      name="thread-{}".format(index),
      target=lambda: download(url),
   )
   for index, url in enumerate(urls)
]

print("Starting threads...")
for t in threads:
   t.start()
print("Waiting for threads to finish...")
for t in threads:
   t.join()
print("Threads all done, now Blender can continue")
```

This an example of an **unsupported** case, where a timer which runs many times
a second:

```
from threading import Timer

def my_timer():
      t = Timer(0.1, my_timer)
      t.setDaemon(True)
      t.start()
      print("Running...")

my_timer()
```

Use cases like the one above, which leave the thread running once the script
finishes, may seem to work for a while, but end up causing random crashes or
errors in Blender’s own drawing code.
user: How do I use Cone in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates a cone- or pyramid-shaped mesh. Useful for modeling objects like spikes, traffic cones, or wizard hats.
You can also create frustums (truncated cones) or simple pyramids by adjusting the top radius.

Vertices
:   Number of vertices used to define the circular base (or polygon base in the case of a pyramid).
    Higher values produce smoother curves.

Radius 1
:   Radius of the base of the cone (bottom circle).

Radius 2
:   Radius of the tip (top circle). A value of 0 creates a standard cone with a pointed tip.
    Non-zero values result in a frustum shape.

Depth
:   Height of the cone along the Z axis.

Cap Fill Type
:   Determines how the base of the cone is filled:

    Nothing:
    :   No bottom cap is added. Only the side faces are created.
        Useful for creating open containers or hollow cones.

    N-gon:
    :   Fills the base with a single N-gon face.

    Triangle Fan:
    :   Fills the base with triangular faces sharing a central vertex.
user: Provide the full official documentation entry for Interface, preserving all code examples.

assistant: [image reference removed]

Panel layout (Blur effect as an example).

The visual effects panels and interface are similar to modifiers.
Each effect shares the same basic interface components similar to modifiers for meshes.

See [Modifiers Interface](../../modeling/modifiers/introduction.xhtml#bpy-types-modifier-show) for more information.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Color
:   RGB color interpolated from the attribute.

Vector
:   XYZ vector interpolated from the attribute.

Factor
:   Scalar value interpolated from the attribute.

Alpha
:   Alpha channel of the attribute, when available. If the attribute has no alpha channel, generally defaults to 1.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Switch
:   - When it is unchecked, the first input labeled “Off” is passed to the output.
    - When checked, the second input labeled “On” is passed to the output.

Off
:   First image input.

On
:   Second image input.
user: How do I use Wrap Methods in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Nearest Surface Point

This will select the nearest point over the surface of the shrunk target.

### Project

[image reference removed]

Project mode.

This will project vertices along a chosen axis until they touch the shrink target.
Vertices that never touch the shrink target are left in their original position.

Limit
:   This is a distance limit between original point and surface.
    If the distance is larger than this limit point would not be projected onto the surface.

Subdivision Levels
:   This applies a (temporary) *Catmull-Clark* subdivision to the modified object’s geometry,
    before computing the wrap.

Axis
:   Along which local axis of the modified object the projection is done.
    These options can be combined with each other, yielding a “median axis” of projection.
    If none are selected, the normal direction is used.

Negative/Positive
:   This allows you to select the allowed direction(s) of the shrink along the selected axis.
    If both options are enabled, both ways are evaluated and the closest hit is selected.

Face Cull
:   Allows you to prevent any projection over the “front side”
    (respectively the “back side”) of the target’s faces. The “side” of a face is determined
    by its normal (front being the side “from where” the normal “originates”).

Invert Cull
:   If *Cull Faces* is enabled, and *Negative* direction along axis is allowed,
    this option can be used to invert the *Front* or *Back* cull choice
    for the *Negative* direction. This is useful when projecting in both directions.

Auxiliary Target
:   An additional object to project over.

### Nearest Vertex

This will snap vertices to the nearest vertex of the shrunk target. It adds no extra options.

This method doesn’t support the *Snap Mode* setting.

### Target Normal Project

This mode is similar to *Nearest Surface Point*, but produces a much smoother
projection in return for being significantly slower.

Instead of finding the closest point, it searches for the nearest point
that has its interpolated smooth normal pointing towards or away from the original point position.
Non-manifold boundary edges are specially handled as infinitely thin cylinders
that emit normals in all perpendicular directions; ignores flat shading.
user: What is Material Node and how is it used in Blender Python scripting?

assistant: # Material Node

[image reference removed]

The *Material* input node outputs a single material. It can be connected to other material sockets
to make using the same material name in multiple places more convenient.
user: Give a detailed overview of CompositorNodeDisplace(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeDisplace(CompositorNode)

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

*class* bpy.types.CompositorNodeDisplace(*CompositorNode*)
:   Displace pixel position using an offset vector

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Searching for Operators in complete detail according to the official Blender documentation.

assistant: ### Menu Search

The Menu Search pop-up lets you search Blender’s interface for a certain
[operator](#) and execute it.
First narrow down the list by typing (part of) the operator’s name,
then either click the operator with `LMB`, or navigate to it with
`Down` and `Up` and activate it with `Return`.

Apart from the operator names, the pop-up also shows the menus
where they’re located.

[image reference removed]

The Menu Search pop-up.

### Operator Search

When [Developer Extras](../editors/preferences/interface.html#bpy-types-preferencesview-show-developer-ui) are activated,
the Operator Search can be accessed from the Edit menu in the Topbar.
This menu searches all [Operators](#)
within Blender, even if they are not exposed in a menu.
This is useful for Python developers for testing purposes.
Blender might also include a few advanced operators that are not
exposed in a menu and can only be accessed via this search menu.
user: Give a detailed overview of Sampling: syntax, arguments, return values, common patterns.

assistant: # Sampling

EEVEE uses a process called Temporal Anti-Aliasing (TAA) which reduces [Aliasing](../../../glossary/index.xhtml#term-Aliasing).
TAA is sample based so the more samples the more aliasing is reduced at the cost of performance.
user: Give a detailed overview of Multiple Importance Sampling: syntax, arguments, return values, common patterns.

assistant: Materials with emission shaders can be configured to use
Multiple Importance Sampling ([Material Settings](../material_settings.xhtml)).
This means that they will get rays sent directly towards them,
rather than ending up there based on rays randomly bouncing around.
For very bright mesh light sources, this can reduce noise significantly.
However, when the emission is not particularly bright,
this will take samples away from other brighter light sources for which it is important to find them this way.

The optimal setting here is difficult to guess; it may be a matter of trial and error,
but often it is clear that a somewhat glowing object may be only contributing light locally,
while a mesh light used as a light would need this option enabled.
Here is an example where the emissive spheres contribute little to the lighting,
and the image renders with slightly less noise by disabling Multiple Importance on them.

|  |  |
| --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_sample-lamp.jpg   Multiple Importance off. | ../../../_images/render_cycles_optimizations_reducing-noise_no-sample-lamp.jpg   Multiple Importance on. |

The world background also has a *Multiple Importance* ([Settings](../world_settings.xhtml#render-cycles-integrator-world-settings)) option.
This is mostly useful for environment maps that have small bright spots in them, rather than being smooth.
This option will then, in a preprocess, determine the bright spots, and send light rays directly towards them. Again,
enabling this option may take samples away from more important light sources if it is not needed.
user: Describe Degenerate Dissolve from the Blender manual or Python API, including usage steps and snippets.

assistant: Collapses any selected edges that are shorter than a certain length.
This also results in the removal of small faces.

If two vertices are near to each other but are not connected by an edge,
they will not be merged; you can use [Merge by Distance](#bpy-ops-mesh-remove-doubles)
for that.

Merge Distance
:   Edges shorter than this length will be collapsed.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: ### Disjoint / Conjoint / Over

The example below shows how different alpha compositing types affect the blending of multiple layers.
Four image layers are assembled using the *Disjoint*, *Conjoint*, and *Over* methods
to create depth between overlapping elements.

[[image reference removed]](../../../_images/compositing_types_converter_color-ramp_create-alpha-mask.png)

Assembling a composite image using Alpha Over.

### Fade In

This example uses a [Time Curve Node](../input/scene/time_curve.html)
to gradually animate the *Factor* input of the *Alpha Over* node from 0 to 1 over 30 frames.
The result is a smooth fade-in of text over a background image.

[[image reference removed]](../../../_images/compositing_types_color_alpha-over_example.png)

Animated fade-in effect using Alpha Over.
user: How do I use Basic Setup in Blender? Include parameters, examples, warnings and best practices.

assistant: The Spline IK Constraint is not strictly an *Inverse Kinematics* method (i.e. IK Constraint),
but rather a *Forward Kinematics* method (i.e. normal bone posing). However,
it still shares some characteristics of the IK Constraint,
such as operating on multiple bones, not being usable for Objects,
and being evaluated after all other constraints have been evaluated. It should be noted that
if a Standard IK chain and a Spline IK chain both affect a bone at the same time the Standard
IK chain takes priority. Such setups are best avoided though,
since the results may be difficult to control.

To setup Spline IK,
it is necessary to have a chain of connected bones and a curve to constrain these bones to:

1. With the last bone in the chain selected,
   add a [Spline IK](../../../../constraints/tracking/spline_ik.xhtml)
   Constraint from the Bone Constraints tab in the Properties.
2. Set the *Chain Length* setting to the number of bones in the chain
   (starting from and including the selected bone) that should be influenced by the curve.
3. Finally, set the *Target* field to the curve that should control the curve.

Congratulations, the bone chain is now controlled by the curve.
user: What is CollectionObjects(bpy_struct) and how is it used in Blender Python scripting?

assistant: # CollectionObjects(bpy_struct)

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

*class* bpy.types.CollectionObjects(*bpy_struct*)
:   Collection of collection objects

    link(*object*)
    :   Add this object to a collection

        Parameters:
        :   **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (never None)) – Object to add

    unlink(*object*)
    :   Remove this object from a collection

        Parameters:
        :   **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object")) – Object to remove

    *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 Edge Bevel Weight, preserving all code examples.

assistant: Sets the value for the `bevel_weight_edge` attribute, a value between (0.0 to 1.0).

This attribute is used by the [Bevel Modifier](../../../modifiers/generate/bevel.html)
to control the bevel intensity of the edges.

This operator enters an interactive mode (a bit like transform tools),
where by moving the mouse (or typing a value with the keyboard)
you can set the bevel weight of selected edges. If more than one edge is selected,
this operator alters the average weight of the edges.
user: Describe Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: - OpenVDB excels at representing sparse volumes, that aren’t necessarily
  concentrated within a tight bounding box but may be spread out through space.
  However, in Blender, these are still rendered as dense volumes
  which is not ideal for performance and memory usage. This will be improved in future releases.
- OpenVDB files can also store level sets and points.
  While level set grids can be read, there is no current support for rendering them as surfaces.
  Importing OpenVDB points is not supported.
user: Explain Set Curve Type in complete detail according to the official Blender documentation.

assistant: Sets the spline type for the splines in the stroke component that are in the selection.

Type
:   Specifies the target spline type. For more details on spline types, see the
    [Spline Types](../../../modeling/curves/structure.xhtml#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: Explain Player Options in complete detail according to the official Blender documentation.

assistant: Ping Pong
:   When enabled, playback loops forwards than backwards.

X/Y Flip
:   Flip the image horizontally or vertically.

    *Viewing the animation from a different perspective can help you see the animation with “fresh eyes”.*
user: Explain Inputs in complete detail according to the official Blender documentation.

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

Vector
:   Vector used as seed in 2D, 3D, and 4D dimensions.

W
:   Value used as seed in 1D and 4D dimensions.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

[image reference removed]

Multi-view is a complete toolset for working with stereoscopic rendering in Blender.
It works with both the EEVEE and Cycles rendering engines.
Cycles additionally supports stereoscopic panoramic cameras.
There is support for many different stereo 3D visualization types.
user: What is Transform Orientation Items and how is it used in Blender Python scripting?

assistant: # Transform Orientation Items

GLOBAL:
:   Global.

    Align the transformation axes to world space.

LOCAL:
:   Local.

    Align the transformation axes to the selected objects’ local space.

NORMAL:
:   Normal.

    Align the transformation axes to average normal of selected elements (bone Y axis for pose mode).

GIMBAL:
:   Gimbal.

    Align each axis to the Euler rotation axis as used for input.

VIEW:
:   View.

    Align the transformation axes to the window.

CURSOR:
:   Cursor.

    Align the transformation axes to the 3D cursor.

PARENT:
:   Parent.

    Align the transformation axes to the object’s parent space.
user: Provide the full official documentation entry for Numeric Input, preserving all code examples.

assistant: # Numeric Input

Using the mouse for transformations is convenient, but if you require more precise control,
you can also enter numeric values. After pressing the shortcut type a number
to indicate the magnitude of the transformation. Then confirm or cancel.
E.g. pressing `S` `2`, `Return` will double the scale of an object.

Move `G`
:   By default and with no other key presses, the translation will occur along the X axis.

Rotation `R`
:   The rotation is in clockwise direction for positive values.

Scale `S`
:   Scaling works in almost identical fashion to translation.
    The primary difference is that by default, scaling applies equally to all three axes.

You can see the numbers you enter in the 3D Viewport footer.

[image reference removed]

Numeric input displayed in the footer.