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

assistant: Image
:   The input RGBA image to be processed.

Factor
:   Blend factor for how strongly the node affects the image.
    A value of 1.0 fully applies the effect; lower values blend with the original.

Spill Channel
:   Selects which channel to reduce:

    R:
    :   Suppress red spill.

    G:
    :   Suppress green spill (common for green screens).

    B:
    :   Suppress blue spill (common for blue screens).

Limit Method
:   Chooses the method for spill reduction:

    Simple:
    :   Compares the *Limiting Channel* channel to the others and reduces it if it is higher.

    Average:
    :   Uses the average of the other two channels to set the limit for the despill channel.

Limit Channel Simple
:   When using the *Simple* algorithm, you can choose which channel(s) to use as a reference for limiting:

    R:
    :   Use red as the reference.

    G:
    :   Use green as the reference.

    B:
    :   Use blue as the reference.

Limit Strength
:   Specifies the limiting strength of the limit channel.

### Spill Strength

If enabled, the spill strength for each color channel can be specified.
If disabled, the spill channel will have a unit scale, while other channels will be zero.

Strength
:   Specifics the spilling strength of each color channel.
user: How do I use TextureNodeCoordinates(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeCoordinates(TextureNode)

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

*class* bpy.types.TextureNodeCoordinates(*TextureNode*)
:   *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: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`UIList.bl_idname`](bpy.types.UIList.html#bpy.types.UIList.bl_idname "bpy.types.UIList.bl_idname") - [`UIList.list_id`](bpy.types.UIList.html#bpy.types.UIList.list_id "bpy.types.UIList.list_id") - [`UIList.layout_type`](bpy.types.UIList.html#bpy.types.UIList.layout_type "bpy.types.UIList.layout_type") - [`UIList.use_filter_show`](bpy.types.UIList.html#bpy.types.UIList.use_filter_show "bpy.types.UIList.use_filter_show") - [`UIList.filter_name`](bpy.types.UIList.html#bpy.types.UIList.filter_name "bpy.types.UIList.filter_name") | - [`UIList.use_filter_invert`](bpy.types.UIList.html#bpy.types.UIList.use_filter_invert "bpy.types.UIList.use_filter_invert") - [`UIList.use_filter_sort_alpha`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_alpha "bpy.types.UIList.use_filter_sort_alpha") - [`UIList.use_filter_sort_reverse`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_reverse "bpy.types.UIList.use_filter_sort_reverse") - [`UIList.use_filter_sort_lock`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_lock "bpy.types.UIList.use_filter_sort_lock") - [`UIList.bitflag_filter_item`](bpy.types.UIList.html#bpy.types.UIList.bitflag_filter_item "bpy.types.UIList.bitflag_filter_item") - [`UIList.bitflag_item_never_show`](bpy.types.UIList.html#bpy.types.UIList.bitflag_item_never_show "bpy.types.UIList.bitflag_item_never_show") |
user: Give a detailed overview of Troubleshooting Windows – Other GPU: syntax, arguments, return values, common patterns.

assistant: # Troubleshooting Windows – Other GPU

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: How do I use Reducing Noise in Blender? Include parameters, examples, warnings and best practices.

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: Show practical ways to work with ShaderNodeWavelength(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeWavelength(ShaderNode)

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Compositing, preserving all code examples.

assistant: Blend
:   The method for blending the current strip with strips in lower channels.
    See [Blend Modes](../../../../glossary/index.html#term-Blend-Modes) for more information.

Opacity
:   The opacity ([alpha](../../../../glossary/index.html#term-Alpha-Channel)) of the strip.

    When this property is animated, the opacity is drawn as an overlay on the strip.
    The overlay will look like a dark section that follows the animation curve.
    This can be hidden by disabling the [F-Curves](../display.html#bpy-types-sequencertimelineoverlay-show-fcurves).
user: How do I use NodesModifierBakeDataBlocks(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodesModifierBakeDataBlocks(bpy_struct)

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

*class* bpy.types.NodesModifierBakeDataBlocks(*bpy_struct*)
:   Collection of data-blocks that can be referenced by baked data

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Light Probe Volume

A volume probe records the light incoming from all directions at many locations inside a volume.

The light is then filtered and only the diffuse light is recorded.
The capture point positions are visible as an overlay when the Irradiance Volume object is selected.

If an object is not inside any Irradiance Volume, or if the indirect lighting has not been baked,
the world’s diffuse lighting will be used to shade it.
user: Show practical ways to work with FunctionNodeAlignEulerToVector(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeAlignEulerToVector(FunctionNode)

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

*class* bpy.types.FunctionNodeAlignEulerToVector(*FunctionNode*)
:   Orient an Euler rotation along the given direction

    axis
    :   Axis to align to the vector

        - `X`
          X – Align the X axis with the vector.
        - `Y`
          Y – Align the Y axis with the vector.
        - `Z`
          Z – Align the Z axis with the vector.

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

    pivot_axis
    :   Axis to rotate around

        - `AUTO`
          Auto – Automatically detect the best rotation axis to rotate towards the vector.
        - `X`
          X – Rotate around the local X axis.
        - `Y`
          Y – Rotate around the local Y axis.
        - `Z`
          Z – Rotate around the local Z axis.

        Type:
        :   enum in [`'AUTO'`, `'X'`, `'Y'`, `'Z'`], default `'AUTO'`

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

assistant: # Position Node

[image reference removed]

The *Position* node outputs a vector of each point of the geometry the node is connected to.

The node can work on geometry domains besides points. In that case, the position data will be
automatically interpolated to the new domain. For example, when used as part of the input to
the [Split Edges Node](../../mesh/operations/split_edges.html), the position for each edge
will be the average position of the edge’s two vertices.

For instances themselves, the output is the origin of each instance. However, if the node is for
a geometry node that adjusts data inside instances, the position output of this node will be
in the local space of each instance. See the [Instance Processing](../../instances.html#geometry-nodes-instance-processing) page
for more details.
user: Explain Spin in complete detail according to the official Blender documentation.

assistant: Similar to its [mesh counterpart](../../meshes/tools/spin.xhtml), this operator
extrudes the selected control points several times along a circle that’s centered on
the [3D Cursor](../../../editors/3dview/3d_cursor.xhtml) and parallel to the viewing plane.
The [weights](../structure.xhtml#modeling-surfaces-weight) of the new control points are set up
to produce a circle, and the surface is marked as *Cyclic*, *Bézier*, and *Endpoint*
in the extrusion direction (see [Active Spline](../properties/active_spline.xhtml)).
user: Give a detailed overview of Annotation Tools: syntax, arguments, return values, common patterns.

assistant: The annotation tool can be activated in the Toolbar and has the following sub-tools:

Annotate
:   Draw free-hand strokes in the main area.

Annotate Line
:   Click and drag to create a line.
    Optionally, you can select the arrow style for the start and end of the line.

Annotate Polygon
:   Click multiple times to create multiple connected lines, then press `Return` or `Esc` to confirm.

Annotate Eraser
:   Click and drag to remove lines.
    The eraser has a *Radius* setting found in Tool Settings.
user: Explain GeometryNodeToolMousePosition(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeToolMousePosition(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.GeometryNodeToolMousePosition(*GeometryNode*)
:   Retrieve the position of the mouse cursor

    *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: Give a detailed overview of Scenes in the Video Sequencer: syntax, arguments, return values, common patterns.

assistant: Scenes can also be used as [Scene Strips](../../video_editing/edit/montage/strips/scene.xhtml) in the
[Video Sequencer](../../editors/video_sequencer/index.xhtml).
This allows you to composite or edit multiple scenes together in one timeline.

For example, each shot of an animation can be stored in its own scene,
and then combined in a master scene that uses scene strips to sequence them in order.
This workflow is useful for multi-shot projects, trailers,
or layout editing without the need to render intermediate files.

When used as strips, scenes are rendered dynamically during playback or rendering,
and they share the same data-blocks unless they were created as full copies.
user: How do I use Pack Data in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Pack Resources

Mark all eligible external resource files used by the blend-file as packed.
Actual packing will happen on the next save of the blend-file.

### Automatically Pack Resources

When enabled, this option will ensure that all eligible external resource files, existing or added later,
are systematically marked as packed.
As with *Pack Resources*, the blend-file must be saved to the drive for this to have an effect.

Disabling that option won’t unpack anything, but future external files
won’t be automatically marked as packed anymore.

### Selective Packing

A single file can be packed by clicking on the little “gift box” icon to the left of its file-path UI widget.
user: Explain Styling in complete detail according to the official Blender documentation.

assistant: The next step is to style the hair. You can change the look of base hairs by changing
the [Physics Settings](../emitter/physics/index.xhtml).

A more advanced way of changing the hair appearance is to use
[Children](../emitter/children.xhtml).
This adds child hairs to the original ones, and has settings for giving them different types of shapes.

You can also interactively style hairs in [Particle Edit Mode](../mode.xhtml).
In this mode, the particle settings become disabled, and you can comb, trim, lengthen, etc. the hair curves.
user: How do I use What is an Add-on? in Blender? Include parameters, examples, warnings and best practices.

assistant: An add-on is simply a Python module with some additional requirements so Blender
can display it in a list with useful information.

To give an example, here is the simplest possible add-on:

```
bl_info = {
    "name": "My Test Add-on",
    "blender": (2, 80, 0),
    "category": "Object",
}
def register():
    print("Hello World")
def unregister():
    print("Goodbye World")
```

`bl_info`
:   is a dictionary containing add-on metadata such as the title,
    version and author to be displayed in the Preferences add-on list.
    It also specifies the minimum Blender version required to run the script;
    older versions won’t display the add-on in the list.

`register`
:   is a function which only runs when enabling the add-on,
    this means the module can be loaded without activating the add-on.

`unregister`
:   is a function to unload anything setup by `register`,
    this is called when the add-on is disabled.

Notice this add-on does not do anything related to Blender
(the `blender_api:bpy` module is not imported for example).

This is a contrived example of an add-on that serves to illustrate the point
that the base requirements of an add-on are simple.

An add-on will typically register operators, panels, menu items, etc,
but it’s worth noting that *any* script can do this,
when executed from the Text editor or even the interactive console –
there is nothing inherently different about an add-on that allows it to integrate with Blender,
such functionality is just provided by the `blender_api:bpy` module for any script to access.

So an add-on is just a way to encapsulate a Python module in a way a user can easily utilize.
user: Explain GeometryNodeProximity(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeProximity(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.GeometryNodeProximity(*GeometryNode*)
:   Compute the closest location on the target geometry

    target_element
    :   Element of the target geometry to calculate the distance from

        - `POINTS`
          Points – Calculate the proximity to the target’s points (faster than the other modes).
        - `EDGES`
          Edges – Calculate the proximity to the target’s edges.
        - `FACES`
          Faces – Calculate the proximity to the target’s faces.

        Type:
        :   enum in [`'POINTS'`, `'EDGES'`, `'FACES'`], default `'FACES'`

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

assistant: # Introduction

There is no single optimal workflow for editing your video projects that fits every case.
Although there certainly are some specific use cases; e.g. tutorial editing,
wedding videos, …, some agreement exists about distinguishing four basic activities.

1. Montage: starting with your raw footage, you’ll have to deliver a coherent and fluent succession
   of strips that tell your story. Clips have to be rearranged, combined, split (cut) and trimmed.
2. Effects: these can be simple transition effects between strips, e.g.
   fade or full-fledged animations, e.g. rolling end credits.
3. Color grading: because your assembled timeline consists of different shots taken
   with different cameras under different lighting conditions, colors can vary widely between them.
   With color grading and color correcting you can harmonize the color perception.
4. Sound: this ranges from adding background music and voice-over to creating special
   sound effects and using third-party software such as Audacity.
user: How do I use Split Toning Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Split Toning Node

[image reference removed]

The *Split Toning* node applies different color tints to the highlights and shadows of an image.
This technique is widely used in photography and color grading to create mood, enhance contrast,
or stylize an image by giving distinct color tones to bright and dark regions.

For example, warm highlights and cool shadows can evoke a cinematic or nostalgic look,
while complementary tones can create stylized or dramatic effects.
user: How do I use Inserting Text in Blender? Include parameters, examples, warnings and best practices.

assistant: You can insert text in two ways: from the internal text buffer or from a text file.

Using an existing text data-block, you can convert it to an object from the Text editor’s header,
select Edit ‣ Text to 3D Object,
*One Object* or *One Object per Line* depending on your needs.

It is also possible to paste from the clipboard or a file, while editing 3D text.

### Accent Characters

Many special characters (such as accented chars, which are not directly available on your keyboard)
can be “composed” using a combination of two other characters. To do so,
type the main char, press `Alt`-`Backspace`,
and then press the desired “modifier” to produce the special character.
Some examples are given below:

|  |  |
| --- | --- |
| - ã: `A`, `Alt`-`Backspace`, `~` - á: `A`, `Alt`-`Backspace`, `'` - à: `A`, `Alt`-`Backspace`, `\` - â: `A`, `Alt`-`Backspace`, `^` - å: `A`, `Alt`-`Backspace`, `O` - æ: `A`, `Alt`-`Backspace`, `E` - ª: `A`, `Alt`-`Backspace`, `-` - ë: `E`, `Alt`-`Backspace`, `"` - ç: `C`, `Alt`-`Backspace`, `,` - ¢: `C`, `Alt`-`Backspace`, `|` | - ø: `O`, `Alt`-`Backspace`, `/` - §: `S`, `Alt`-`Backspace`, `S` - †: `|`, `Alt`-`Backspace`, `-` - ‡: `|`, `Alt`-`Backspace`, `=` - ©: `O`, `Alt`-`Backspace`, `C` - ®: `O`, `Alt`-`Backspace`, `R` - ™: `T`, `Alt`-`Backspace`, `M` - ½: `1`, `Alt`-`Backspace`, `2` - ÷: `-`, `Alt`-`Backspace`, `:` - ±: `-`, `Alt`-`Backspace`, `+` |
user: Describe Normalized Weight Workflow from the Blender manual or Python API, including usage steps and snippets.

assistant: In order to be used for things like deformation, weights usually have to be normalized,
so that all deforming weights assigned to a single vertex add up to 1.
The *Armature* modifier in Blender does this automatically, so it is technically not necessary to
ensure that weights are normalized at the painting stage.

However, while more complicated, working with normalized weights has certain advantages,
because it allows use of certain tools designed for them, and because when weights are normalized,
understanding the final influence of the current group does not require knowing weights in
other groups on the same vertex.

These tools are provided to aid working with normalized weights:

Normalize All
:   In order to start working with normalized weights it is first necessary to normalize the existing weights.
    The [Normalize All](editing.html#bpy-ops-object-vertex-group-normalize-all) tool can be used for that.
    Make sure to select the right mode and disable *Lock Active*.

Auto Normalize
:   Once the weights are initially normalized,
    the [Auto Normalize](tool_settings/options.html#bpy-types-toolsettings-use-auto-normalize) option
    can be enabled to automatically maintain normalization as you paint.
    This also tells certain tools that the weights are supposed to be already normalized.

Vertex group locking
:   Any vertex group can be locked to prevent changes to it. This can be done via
    the lock icon in the vertex group list, or using bone selection and
    the [locks pie menu](editing.html#bpy-ops-object-vertex-group-lock).

    This setting prevents accidental edits to groups. However,
    since it is also respected by *Auto Normalize*, in the normalized weight workflow
    it has a more significant meaning of locking the current influence of chosen bones,
    so that when you paint other bones, the weight is redistributed only between the unlocked groups.

    In locations affected by multiple bones, this allows more precise tweaking and re-balancing of
    weights by temporarily focusing on a subset of bones. This can also be aided by
    the [Lock Relative](tool_settings/options.html#bpy-types-toolsettings-use-auto-normalize) option, which displays unlocked groups as
    though re-normalized with the locked groups deleted, thus making it appear as if the locked groups did not even
    exist.

Multi-Paint
:   Finally, the [Multi-Paint](tool_settings/options.html#bpy-types-toolsettings-use-auto-normalize) option allows treating
    multiple selected bones as if they were one bone, so that the painting operations change
    the combined weight, preserving the ratio within the group. Combined with locking,
    this allows balancing between one set of bones versus the rest, excluding a third set
    that has its influence not affected in any way due to locks.

    Technically, this option does not require the normalized workflow, but since non-normalized
    weights can add to more than 1, the weight display behaves best with *Auto Normalize* enabled.
user: Show practical ways to work with Interface in a Blender add-on or script – include code.

assistant: ### Header Menus

#### View Menu

Zoom In / Zoom Out
:   Increases/decreases the font size.

Move to Previous Word `Ctrl`-`Left`
:   Moves the cursor to the beginning of the previous word.
    If the cursor is in the middle of a word, the cursor is moved to the beginning of the current word.

Move to Next Word `Ctrl`-`Right`
:   Moves the cursor to the end of the next word.
    If the cursor is in the middle of a word, the cursor is moved to the end of the current word.

Move to Line Begin `Home`
:   Moves the cursor to the start of the current line.

    `Shift`-`Home`: Selects all text between the cursor and the start of the current line.

Move to Line End `End`
:   Moves the cursor to the end of the current line.

    `Shift`-`End`: Selects all text between the cursor and the end of the current line.

#### Console Menu

Clear All
:   Refreshes the console, giving the view a fresh start.
    Note that command history is not cleared.

Clear Line `Shift`-`Return`.
:   Removes everything from the prompt line.

Delete Previous Word `Ctrl`-`Backspace`
:   Deletes everything between the cursor and the beginning of the previous word (separated by periods).
    If the cursor is in the middle of a word, deletes everything to the beginning of the current word.

Delete Next Word `Ctrl`-`Delete`
:   Deletes everything between the cursor and the end of the next word.
    If the cursor is in the middle of a word, deletes everything to the end of the current word.

Copy as Script `Shift`-`Ctrl`-`C`
:   Copies the full history buffer to the clipboard.
    This can be pasted into a text file to be used as a Python script.

Cut `Ctrl`-`X`
:   Copies the selected text into the clipboard and deletes it.

Copy `Ctrl`-`C`
:   Copies the selected text into the clipboard.

Paste `Ctrl`-`V`
:   Pastes into the command line.

Indent `Tab`
:   Inserts a tab character at the cursor.

Unindent `Shift`-`Tab`
:   Unindents the selection.

Backward in History `Up`
:   Changes the current command to the previous one from the command history.

Forward in History `Down`
:   Changes the current command to the next one from the command history.

Autocomplete `Tab`
:   See [Auto Completion](#auto-completion).

### Main View

Key Bindings

- `LMB` – Moves the cursor along the input line.
- `Left` / `Right` – Moves the cursor by one character.
- `Ctrl`-`Left` / `Ctrl`-`Right` – Moves the cursor by one word.
- `Shift`-`Left` / `Shift`-`Right` – Selects characters to the left/right.
- `Shift`-`Ctrl`-`Left` / `Shift`-`Ctrl`-`Right` – Selects words to the left/right.
- `Ctrl`-`A` Selects all text and text history.
- `Backspace` / `Delete` – Erase characters.
- `Ctrl`-`Backspace` / `Ctrl`-`Delete` – Erase words.
- `Return` – Execute command.
- `Shift`-`Return` – Add to command history without executing.
user: How do I use Bundling Extensions in Blender? Include parameters, examples, warnings and best practices.

assistant: When working offline or in a more controlled environment, it may be useful
to provide a set of extensions to all users. For this there is a default
read-only System repository. This repository could be located on a
read-only network drive or in a system directory.

[image reference removed]

System repository

The `$BLENDER_SYSTEM_EXTENSIONS`
[environment variable](command_line/arguments.xhtml#command-line-args-environment-variables)
controls the default location. This should point to a directory, within
which a `system` directory should exist.

Extensions packages should be extracted in this `system` directory,
with a resulting path like this:

```
$BLENDER_SYSTEM_EXTENSIONS/system/my-addon/blender_manifest.toml
```

In the Extensions preferences, it’s possible to manually set a custom
directory for the default System repository, or to create multiple
repositories.
user: How do I use Target Selection in Blender? Include parameters, examples, warnings and best practices.

assistant: Sets more detailed snapping options. The available options depend on the mode
(Object/Edit) as well as the [Snap Target](#bpy-types-toolsettings-snap-elements-base).

Include Active Edit Mode
:   Snap to other mesh elements of the active object.

    This checkbox is ignored if
    [Proportional Editing](proportional_editing.html)
    is enabled.

Include Edited Edit Mode
:   Snap to other objects that are also in Edit Mode.

Include Non-Edited Edit Mode
:   Snap to other objects that are not in Edit Mode.

Exclude Non-Selectable
:   Snap only to objects that are selectable.

Align Rotation to Target
:   Rotates the selection so that its Z axis gets aligned to the normal of the target.

Backface Culling
:   Exclude back-facing geometry from snapping.

Snap to Same Target Face Nearest
:   Snap only to the object which the selection was nearest to before starting
    the transformation.

Face Nearest Steps Face Nearest Edit Mode
:   Breaks the overall transformation into multiple steps, performing a snap each time.
    This can give better results in certain cases.

Snap Peel Object Volume
:   If the target object is composed of several disconnected mesh islands that
    intersect each other, “Snap To Volume” will normally snap to the island which the
    mouse is hovering over, ignoring the other islands. By enabling “Snap Peel Object,”
    you can instead treat the target object as one connected whole.
user: How do I use Tool Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Brush Asset

The asset selector can be used to open a pop-up asset browser to select the active brush asset for the tool.

See [Asset Operators](../../../../sculpt_paint/brush/brush_management.html#brush-management-utility-operators) for more information.

### Brush Settings

You can also configure the brush main settings exposed on the Tool Settings for convenience.

Direction `Ctrl`
:   The portion of area to fill.

    Normal:
    :   Fills the area inside the shape under the cursor.

    Inverted:
    :   When clicking outside the drawing, fills all shapes touching the area under the cursor.

Precision
:   Multiplier for fill boundary accuracy.
    Higher values are more accurate but slower.

Dilate/Contract
:   Size in pixels to expand or shrink the fill area from the strokes boundary.

Thickness
:   The thickness radius of the boundary stroke in pixels.

#### Advanced

Boundary
:   Sets the type of fill boundary limits calculation to perform.

    All:
    :   Use the thickness of the strokes and the editing lines together.

    Strokes:
    :   Use only the thickness of the strokes (ignore edit lines).

    Edit Lines:
    :   Use only the edit lines (ignore strokes).

    Show Lines (eye icon)
    :   Toggle show auxiliary lines to see the fill boundary.

Layers
:   Determines which [Layers](../../../properties/layers.html) are used for boundary strokes.

    Visible:
    :   Calculates boundaries based on all visible layers.

    Active:
    :   Calculates boundaries based on the active layer.

    Layer Above:
    :   Calculates boundaries based on the layer above the active layer.

    Layer Below:
    :   Calculates boundaries based on the layer below the active layer.

    All Above:
    :   Calculates boundaries based on all layers above the active layer.

    All Below:
    :   Calculates boundaries based on all layers below the active layer.

Simplify
:   Number of simplify steps to apply to the boundary line.
    Higher values reduce the accuracy of the final filled area.

Ignore Transparent
:   When enabled, strokes with transparency does not take into account on fill boundary calculations.

    The value slider controls the threshold to consider a material transparent.

Limit to Viewport
:   When enabled, fill only visible areas in the viewport.

Auto-Remove Fill Guides
:   When enabled, after creating a fill, automatically remove the fill guide strokes.

##### Gap Closure

Gap closure lines are automatic temporarily lines that help to close gaps on the strokes.

Size
:   Control the Size of the line extension or the circumference to use to calculate the lines that will close the gaps.

Mode `S`
:   Sets the type of Gap closure method to use.

    Radius:
    :   Uses the Radius of circumference of opened nearest points to calculate a line that close the gap.

    Extend:
    :   Extends the opened strokes to close gaps.

Visual Aids
:   Toggle show closure lines helper.

Strokes Collision `D`
:   Check if extend lines collide with strokes, stopping the extension if a collision is detected.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GreasePencil.layers`](bpy.types.GreasePencil.html#bpy.types.GreasePencil.layers "bpy.types.GreasePencil.layers") - [`GreasePencilv3Layers.active`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.active "bpy.types.GreasePencilv3Layers.active") - [`GreasePencilv3Layers.move`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move "bpy.types.GreasePencilv3Layers.move") - [`GreasePencilv3Layers.move_bottom`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_bottom "bpy.types.GreasePencilv3Layers.move_bottom") | - [`GreasePencilv3Layers.move_to_layer_group`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_to_layer_group "bpy.types.GreasePencilv3Layers.move_to_layer_group") - [`GreasePencilv3Layers.move_top`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_top "bpy.types.GreasePencilv3Layers.move_top") - [`GreasePencilv3Layers.new`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.new "bpy.types.GreasePencilv3Layers.new") - [`GreasePencilv3Layers.remove`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.remove "bpy.types.GreasePencilv3Layers.remove") |
user: Show practical ways to work with Line Art in a Blender add-on or script – include code.

assistant: # Line Art

[image reference removed]

Line Art material properties.

Material Mask
:   Material masks are a way to provide Line Art extra information about faces that caused the occlusion.
    So edges occluded by those faces can be selected to have different styles.

Masks
:   The layer to include faces of the current material.

Levels
:   Faces with this material will behave as if it has set number of layers in occlusion.

Intersection Priority
:   Assigns an intersection priority value for this material.
    Note that this priority takes precedent over [Object](../../scene_layout/object/properties/line_art.html#bpy-types-objectlineart-intersection-priority)
    or [Collection](../../scene_layout/collections/collections.html#bpy-types-collection-lineart-intersection-priority) priority values.
    The intersection line will be included into the object with the higher intersection priority value.
user: Provide the full official documentation entry for Bundled Assets, preserving all code examples.

assistant: Blender includes many assets out of the box, these are contained in the “Essentials” library.

Included in this library are:

- [Hair node groups](../../modeling/geometry_nodes/hair/index.html)
- [Smooth By Angle Node Group](../../modeling/geometry_nodes/normals/smooth_by_angle.html)
- Brushes:

  - [Mesh Sculpt](../../sculpt_paint/sculpting/brushes/index.html)
  - [Curve Sculpt](../../sculpt_paint/curves_sculpting/brushes/index.html)
  - [Texture Paint](../../sculpt_paint/texture_paint/brushes.html)
  - [Vertex Paint](../../sculpt_paint/vertex_paint/brushes.html)
  - [Weight Paint](../../sculpt_paint/weight_paint/brushes.html)
user: Explain BlendDataSpeakers(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BlendDataSpeakers(bpy_struct)

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

*class* bpy.types.BlendDataSpeakers(*bpy_struct*)
:   Collection of speakers

    new(*name*)
    :   Add a new speaker to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New speaker data-block

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

    remove(*speaker*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a speaker from the current blendfile

        Parameters:
        :   - **speaker** ([`Speaker`](bpy.types.Speaker.html#bpy.types.Speaker "bpy.types.Speaker"), (never None)) – Speaker to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this speaker before deleting it (WARNING: will also delete objects instancing that speaker data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this speaker data
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this speaker data

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: # Global Transform

Copy and paste object and bone transforms with ease.

When copying, the global ([World Space](../../../glossary/index.html#term-World-Space)) transform is placed on the clipboard.
This can then be pasted onto any object or bone, at the current frame or at another one.

[image reference removed]

The figure on the right shows the main functionality of the Copy Global
Transform panel. The collapsed panels are described each in their own section
below.

Copy
:   Inspects the active Object (in Object mode) or Bone (in Pose mode) and places
    its current global transform onto the clipboard as a matrix.

Paste
:   Takes the copied global transform and applies it to the active Object or Bone.
    This is done by **adjusting its location, rotation, and scale properties**.

Mirrored
:   Same as ‘Paste’ above, but then mirrored relative to some other object or
    bone. This can be useful, for example, to copy the foot position of one foot
    to the other. See [Mirror](#copy-global-transform-mirror-options) below.

Paste to Selected Keys
:   Paste as described above and additionally use auto-keying to update one or
    more frames. The key selection is used to tell Blender *which frames* this
    should happen on; it does not influence which parts of the transform are
    keyed. *What* is keyed is determined by the active keying set.

Paste and Bake
:   Almost the same as *Paste to Selected Keys*. Instead of only pasting on the
    selected keys, *Paste and Bake* will paste & auto-key on every frame between
    the first and last selected keys.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Mesh
:   Standard geometry input.

Selection
:   A standard Boolean selection input to determine which faces will be triangulated.

Quad Method
:   Beauty:
    :   Split the quads in nice triangles, slower method.

    Fixed:
    :   Split the quads on their 1st and 3rd vertices.

    Fixed Alternate:
    :   Split the quads on their 2nd and 4th vertices.

    Shortest Diagonal:
    :   Split the quads along their shortest diagonal.

    Longest Diagonal:
    :   Split the quads along their longest diagonal. This is the preferred mode for cloth simulations.

N-gon Method
:   Beauty:
    :   Arrange the new triangles nicely, slower method.

    Clip:
    :   Split n-gons using an ear-clipping algorithm
        (the same method of tessellation used for viewport display).