PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for UserAssetLibrary(bpy_struct), preserving all code examples.

assistant: # UserAssetLibrary(bpy_struct)

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

*class* bpy.types.UserAssetLibrary(*bpy_struct*)
:   Settings to define a reusable library for Asset Browsers to use

    import_method
    :   Determine how the asset will be imported, unless overridden by the Asset Browser

        - `LINK`
          Link – Import the assets as linked data-block.
        - `APPEND`
          Append – Import the assets as copied data-block, with no link to the original asset data-block.
        - `APPEND_REUSE`
          Append (Reuse Data) – Import the assets as copied data-block while avoiding multiple copies of nested, typically heavy data. For example the textures of a material asset, or the mesh of an object asset, don’t have to be copied every time this asset is imported. The instances of the asset share the data instead..
        - `PACK`
          Pack – Import the asset as linked data-block, and pack it in the current file (ensures that it remains unchanged in case the library data is modified, is not available anymore, etc.).

        Type:
        :   enum in [`'LINK'`, `'APPEND'`, `'APPEND_REUSE'`, `'PACK'`], default `'PACK'`

    name
    :   Identifier (not necessarily unique) for the asset library

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

    path
    :   Path to a directory with .blend files to use as an asset library

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

    use_relative_path
    :   Use relative path when linking assets from this asset library

        Type:
        :   boolean, default True

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Dependency graph: Original object example: syntax, arguments, return values, common patterns.

assistant: This example demonstrates access to the original ID.
Such access is needed to check whether object is selected, or to compare pointers.

```
import bpy

class OBJECT_OT_original_example(bpy.types.Operator):
    """Access original object and do something with it"""
    bl_label = "DEG Access Original Object"
    bl_idname = "object.original_example"

    def check_object_selected(self, object_eval):
        # Selection depends on a context and is only valid for original objects. This means we need
        # to request the original object from the known evaluated one.
        #
        # NOTE: All ID types have an `original` field.
        obj = object_eval.original
        return obj.select_get()

    def execute(self, context):
        # NOTE: It seems redundant to iterate over original objects to request evaluated ones
        # just to get original back. But we want to keep example as short as possible, but in real
        # world there are cases when evaluated object is coming from a more meaningful source.
        depsgraph = context.evaluated_depsgraph_get()
        for obj in context.editable_objects:
            object_eval = obj.evaluated_get(depsgraph)
            if self.check_object_selected(object_eval):
                self.report({'INFO'}, f"Object is selected: {object_eval.name}")
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_original_example)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_original_example)

if __name__ == "__main__":
    register()
```
user: How do I use Velocity in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Velocity panel.

This panel shows brush options that are based on object velocity.

On top you have a color ramp and several related settings.
Basically the color ramp represents brush velocity values:
left side being zero velocity and right side being the “Max velocity”.
Speed is measured in “units per frame”.

Checkboxes above can be used to define color ramp influence.

Multiply Alpha
:   Uses color ramp’s alpha value depending on current velocity and multiplies brush alpha with it.

Replace Color
:   Replaces the brush color with the values from the [Color Ramp Widget](../../interface/controls/templates/color_ramp.xhtml#ui-color-ramp-widget).

Multiply Depth
:   Multiplies brushes “depth intersection” effect.
    Basically you can adjust displace and wave strength depending on brush speed.

Do Smudge
:   Enabling Smudge makes the brush “smudge” (or “smear”) existing colors on the surface as it moves.
    The strength of this effect can be defined from the *Smudge Strength* property.

    Even when smudge is enabled brush still does its normal paint effect.
    If you want a purely smudging brush use zero alpha.
    It is also possible to have *Erase* option enabled together with smudge.
user: How do I use MeshSkinVertex(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MeshSkinVertex(bpy_struct)

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

*class* bpy.types.MeshSkinVertex(*bpy_struct*)
:   Per-vertex skin data for use with the Skin modifier

    radius
    :   Radius of the skin

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

    use_loose
    :   If vertex has multiple adjacent edges, it is hulled to them directly

        Type:
        :   boolean, default False

    use_root
    :   Vertex is a root for rotation calculations and armature generation, setting this flag does not clear other roots in the same mesh island

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Regions

Every Editor in Blender is divided into Regions.
Regions can have smaller structuring elements like
[tabs and panels](tabs_panels.html)
with buttons, controls and widgets placed within them.

[image reference removed]

The regions of the 3D Viewport showing the Sidebar and
the Adjust Last Operation panel after adding a Cube.

Header (green), Main region (yellow), Toolbar (blue),
Sidebar (red) and Adjust Last Operation panel (pink).
user: Show practical ways to work with GPU Platform Utilities (gpu.platform) in a Blender add-on or script – include code.

assistant: # GPU Platform Utilities (gpu.platform)

This module provides access to GPU Platform definitions.

gpu.platform.backend_type_get()
:   Get actuve GPU backend.

    Returns:
    :   Backend type (‘OPENGL’, ‘VULKAN’, ‘METAL’, ‘NONE’, ‘UNKNOWN’).

    Return type:
    :   str

gpu.platform.device_type_get()
:   Get GPU device type.

    Returns:
    :   Device type (‘APPLE’, ‘NVIDIA’, ‘AMD’, ‘INTEL’, ‘SOFTWARE’, ‘QUALCOMM’, ‘UNKNOWN’).

    Return type:
    :   str

gpu.platform.renderer_get()
:   Get GPU to be used for rendering.

    Returns:
    :   GPU name.

    Return type:
    :   str

gpu.platform.vendor_get()
:   Get GPU vendor.

    Returns:
    :   Vendor name.

    Return type:
    :   str

gpu.platform.version_get()
:   Get GPU driver version.

    Returns:
    :   Driver version.

    Return type:
    :   str
user: What is Bone Collections and how is it used in Blender Python scripting?

assistant: # Bone Collections

[image reference removed]

The Bone Collections panel in the Armature properties.

This panel contains a Tree View to manage [Bone Collection](../bones/bone_collections.html)
From this panel, Bone Collections can be created, deleted, re-arranged, and more.

Collections can be renamed by double clicking on the name, or right clinking and selecting *Rename*.
To nest a collection inside an existing collection, click and drag the name onto another collection’s name.
Child collection can also be made by `RMB` and selecting “Add Child Collection”.

To the right of the name gives a few controls of the collection:

Visible (Eye)
:   Bones in this collection will be visible in the 3D Viewport.

Solo (Star)
:   Show only this bone collection, and others also marked as “solo”.

Further more, collection that are not empty will have a dot to indicate the collection has bones assigned to it.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Normal
:   Vector indicating the normal of each geometry element.

True Normal
:   For meshes, outputs normals without [custom normals](../../../meshes/structure.html#modeling-meshes-normals-custom) attributes taken into
    account.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Text objects contain some text, and are in the same object type family as curves and surfaces ones,
as fonts are vector data (they are made of curves).

Blender uses a “Font System” to manage mapping letter codes to geometry representing them in the 3D Viewport.
This font system has its own *built-in* font, but it can use external fonts too,
including *PostScript Type 1*, *OpenType* and *TrueType* fonts.
And moreover, it can use any objects existing in the current blend-file as letters.

[[image reference removed]](../../_images/modeling_texts_introduction_examples.jpg)

An example of an extruded text.

Text objects allow you to create and render 2D or 3D text,
with various advanced layout options, like justifying and frames.
By default, letters are just flat filled surfaces, exactly like any closed 2D curve.
But, just like curves, you can extrude them,
and apply [modifiers](../modifiers/introduction.html) to them
(e.g. to make them [follow a curve](../modifiers/deform/curve.html)).

Text in Blender can be laid out in some relatively advanced ways,
defining columns or blocks of text, using different alignments, and so on.

Those features are similar in concept to what you can find in DTP software
(like [Scribus](https://www.scribus.net/)), although at a very basic level currently.
user: Show practical ways to work with Switch View Node in a Blender add-on or script – include code.

assistant: # Switch View Node

[image reference removed]

The *Switch View* node combines the *views* (left and right) into a single stereo 3D output.
This can be useful if for example, you need to treat the view as separate images by combining each of the views.
user: How do I use Select Linked in Blender? Include parameters, examples, warnings and best practices.

assistant: Select geometry connected to already selected elements.
This is often useful when a mesh has disconnected, overlapping parts,
where isolating it any other way would be tedious.
Pressing `Shift`-`L` will deselect linked any linked elements.

With `L` you can also select connected geometry directly under the cursor.
user: What is Collision and how is it used in Blender Python scripting?

assistant: # Collision

[Particles](particles/index.xhtml), [Soft Bodies](soft_body/index.xhtml)
and [Cloth objects](cloth/index.xhtml) may collide with mesh objects.
[Boids](particles/emitter/physics/boids.xhtml) try to avoid *Collision* objects.

- You may limit the effect on particles to a group of objects
  (in the [Field Weights panel](particles/emitter/force_field.xhtml)).
- *Deflection* for soft body objects is difficult, they often penetrate the colliding objects.
- Hair particles ignore deflecting objects
  (but you can animate them as soft bodies which take deflection into account).

If you change the deflection settings for an object you have to recalculate the particle,
soft body or cloth system by *Delete Bake*, this is not done automatically.

[image reference removed]

A collider object can be temporarily disabled via an animatable toggle to
the right of the button that permanently activates or deactivates it.
user: Explain Overview in complete detail according to the official Blender documentation.

assistant: To display an image, it must be converted from
[scene linear](color_spaces.xhtml#color-management-linear-space) to a display color space.
This involves both technical and artistic choices.

The technical choice of [display color space](#bpy-types-colormanageddisplaysettings-display-device)
depends on the target display device and its capabilities. sRGB works for all
computer displays, but different choices may be made for digital cinema, HD TVs,
and computers with wide gamut or HDR support.

Because display devices cannot display the full spectrum of colors and only have
limited brightness, colors must be fitted to the gamut of the device. Blender
includes a choice of [views](#bpy-types-colormanagedviewsettings-view-transform),
each resulting in a different look.

Further artistic choices can be made with color management settings like exposure and
white balance, and color grading in the compositor.
.

[image reference removed]

Conversion from linear to display device space.
user: Provide the full official documentation entry for IDOverrideLibraryProperties(bpy_struct), preserving all code examples.

assistant: # IDOverrideLibraryProperties(bpy_struct)

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

*class* bpy.types.IDOverrideLibraryProperties(*bpy_struct*)
:   Collection of override properties

    add(*rna_path*)
    :   Add a property to the override library when it doesn’t exist yet

        Parameters:
        :   **rna_path** (*string**,* *(**never None**)*) – RNA Path, RNA-Path of the property to add

        Returns:
        :   New Property, Newly created override property or existing one

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

    remove(*property*)
    :   Remove and delete a property

        Parameters:
        :   **property** ([`IDOverrideLibraryProperty`](bpy.types.IDOverrideLibraryProperty.html#bpy.types.IDOverrideLibraryProperty "bpy.types.IDOverrideLibraryProperty")) – Property, Override property to be deleted

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

assistant: # Bone Collections

[Bone Collections](../../../glossary/index.xhtml#term-Bone-Collection) group the bones of an
[Armature](../../../glossary/index.xhtml#term-Armature) into named collections. The armature is the owner of these
collections, so they are available in all modes. Bone Collections are identified
by their name, which are unique within the Armature.
Bone Collections can be nested inside other Bone Collections to create an organized hierarchy for complex rigs.

In the text below, “collection” is understood to refer to “bone collection”;
[Scene Collections](../../../glossary/index.xhtml#term-Collection) are not described here.

Bone Collections can be managed via [the Armature and Bone property panels](../properties/bone_collections.xhtml#bpy-types-bonecollection).
user: Show practical ways to work with NodeGeometryRepeatOutputItems(bpy_struct) in a Blender add-on or script – include code.

assistant: # NodeGeometryRepeatOutputItems(bpy_struct)

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

*class* bpy.types.NodeGeometryRepeatOutputItems(*bpy_struct*)
:   Collection of repeat items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`RepeatItem`](bpy.types.RepeatItem.html#bpy.types.RepeatItem "bpy.types.RepeatItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

assistant: Blender is available for download on Windows, macOS, and Linux. Always check that your graphics drivers are up to date
and that OpenGL is properly supported. Blender has a set of [minimum and recommended requirements](https://www.blender.org/download/requirements/); so make sure these are met before trying to install Blender.

Support for other hardware such as graphic tablets and 3D mice are covered later in
[Configuring Hardware](../configuration/hardware.xhtml).
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`Area.spaces`](bpy.types.Area.html#bpy.types.Area.spaces "bpy.types.Area.spaces") - [`AreaSpaces.active`](bpy.types.AreaSpaces.html#bpy.types.AreaSpaces.active "bpy.types.AreaSpaces.active") | - [`Context.space_data`](bpy.types.Context.html#bpy.types.Context.space_data "bpy.types.Context.space_data") |
user: Give a detailed overview of sys.exit: syntax, arguments, return values, common patterns.

assistant: Some Python modules will call `sys.exit()` themselves when an error occurs,
while not common behavior this is something to watch out for because it may seem
as if Blender is crashing since `sys.exit()` will close Blender immediately.

For example, the `argparse` module will print an error and exit if the arguments are invalid.

An dirty way of troubleshooting this is to set `sys.exit = None` and see what line of Python code is quitting,
you could of course replace `sys.exit` with your own function but manipulating Python in this way is bad practice.
user: Show practical ways to work with GeometryNodePointsToVertices(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodePointsToVertices(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.GeometryNodePointsToVertices(*GeometryNode*)
:   Generate a mesh vertex for each point cloud point

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

assistant: Geometry
:   Geometry whose elements are iterated over.

Selection
:   Which subset of the chosen *Domain* to process.

Index
:   Index of the element in the source geometry. Note that the same index can occur more than
    once when iterating over multiple geometry component types at once.

Element
:   The input geometry is split up into a separate geometry for each element.
    This is the single element geometry for the current iteration. This is not available
    for the *Face Corner* domain, since face corners cannot exist without their face.
user: Describe Match String Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Match String Node

[image reference removed]

The *Match String* node compares two string values and outputs a Boolean result based on the selected operation.
It is useful for conditional logic involving string comparisons, such as matching object names or attribute values.
user: Show practical ways to work with Relations in a Blender add-on or script – include code.

assistant: Target
:   This [list view](../../../../interface/controls/templates/list_view.xhtml#ui-list-view) allows you to set up other particle systems to react with the boids.

Target Object
:   A [data ID](../../../../interface/controls/templates/data_block.xhtml#ui-data-id) to select an object with a particle system set on.

System
:   Index of the *Object*‘s particle system as set in the list view in the particle panel.

Mode
:   Enemy:
    :   Setting the type to *Enemy* will cause the systems to fight with each other.

    Friend:
    :   Will make the systems work together.

    Neutral:
    :   Will not cause them to align or fight with each other.

### Deflection

Boids will try to avoid deflector objects according to the Collision rule’s weight.
It works best for convex surfaces (some work needed for concave surfaces).

### Force Fields

As other physics types, Boids is also influenced by external force fields.

In addition, special *Boid* force fields can be used with the Boids physics.
These effectors could be predators (positive Strength) that boids try to avoid,
or targets (negative Strength) that boids try to reach
according to the (respectively) *Avoid* and *Goal* rules of the *Boid Brain*.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`FunctionNodeFormatString.format_items`](bpy.types.FunctionNodeFormatString.html#bpy.types.FunctionNodeFormatString.format_items "bpy.types.FunctionNodeFormatString.format_items") - [`NodeFunctionFormatStringItems.new`](bpy.types.NodeFunctionFormatStringItems.html#bpy.types.NodeFunctionFormatStringItems.new "bpy.types.NodeFunctionFormatStringItems.new") | - [`NodeFunctionFormatStringItems.remove`](bpy.types.NodeFunctionFormatStringItems.html#bpy.types.NodeFunctionFormatStringItems.remove "bpy.types.NodeFunctionFormatStringItems.remove") |
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Triangulate modifier.

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
    :   Splits n-gons using an ear-clipping algorithm
        (the same method of tessellation used for viewport display).

Minimum Vertices
:   Minimum number of vertices a face must have to be triangulated.
    For example, setting this value to 5, will prevent triangulation of [Quads](../../../glossary/index.xhtml#term-Quad)
    and only triangulate [N-gons](../../../glossary/index.xhtml#term-N-gon).
user: Provide the full official documentation entry for Custom Split Normals of Meshes, preserving all code examples.

assistant: Blender supports the import and export of [custom normals](../../modeling/meshes/structure.xhtml#modeling-meshes-normals-custom) to
Alembic files. As a basic rule of thumb, a completely smooth mesh will be exported without normals
and thus produce the smallest Alembic file. This is reflected in the importer; an Alembic mesh
without normals is loaded as a smooth mesh.

On export, for every mesh:

- If it has *Custom Loop Normals* then the loop normals are exported.
- If one or more polygons are marked flat then loop normals are also exported.
- Otherwise, no normals are exported.

On import, when the Alembic mesh contains:

- Loop normals (`kFacevaryingScope`) are used as custom loop normals.
- Vertex normals (`kVertexScope` or `kVaryingScope`) are convert to loop normals, and handle as above.
- If there are no normals then the mesh is marked as smooth.
- Unsupported normal types (`kConstantScope`, `kUniformScope`, `kUnknownScope`) are handled as *no normals*.

When an imported mesh does not contain normals, the final look can be controlled using the
[Normal’s Shading](../../modeling/meshes/structure.xhtml#modeling-meshes-structure-normals-shading).
user: Give a detailed overview of Set Material Index Node: syntax, arguments, return values, common patterns.

assistant: # Set Material Index Node

[image reference removed]

The *Set Material Index* node sets the material index for a geometry.

The node to get this data is the [Material Index](material_index.xhtml) node.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Grid
:   The resulting SDF grid with concave corners rounded off.
    The output can be visualized by converting it to a mesh with
    [Grid to Mesh](grid_to_mesh.html) or
    used in further volumetric operations.
user: Give a detailed overview of Face Set Node: syntax, arguments, return values, common patterns.

assistant: # Face Set Node

[image reference removed]

The *Face Set Node* outputs which [face set](../../../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.html#face-sets) a face is in,
and whether or not face sets exist in the mesh at all.

The corresponding data flow node is the [Set Face Set Node](../write/set_face_set.html).
user: Provide the full official documentation entry for Update Scene Frame Range, preserving all code examples.

assistant: For Scene strips only – Updates the strip’s [Time](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#sequencer-strips-properties-time)
properties to match the referenced scene’s frame range.
This operator should be used when the referenced scene’s length is extended or shortened.
user: Provide the full official documentation entry for Notes, preserving all code examples.

assistant: It is possible that this node will put out a value set that has values beyond the normal range,
i.e. values greater than one and less than zero.
If you will be using the output to mix with other images in the normal range,
you should clamp the values using the Map Value node (with the Min and Max enabled),
or put through a Color Ramp node (with all normal defaults).

[image reference removed]

Clamp the values to normal range.

Either of these nodes will scale the values back to normal range.
In the example image, we want to intensify the specular pass.
The bottom thread shows what happens if we do not clamp the values;
the specular pass has a value much less than one in the dark areas;
when added to the medium gray, it makes black. Passing the brightened image through either
the Map Value or the Color Ramp node produces the desired effect.
user: Describe Export Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Frame
:   Determine which frames will be included in the export.

    Active:
    :   Export only the active keyframe.

    Selected:
    :   Export all selected keyframes as different PDF pages.

    Scene:
    :   Export all frames as different PDF pages.

Sampling
:   Precision for the stroke sampling. Low values mean a more accurate result.

Fill
:   When enabled, export the Grease Pencil strokes fill.

Uniform Width
:   When enabled, export strokes with constant thickness.
user: Provide the full official documentation entry for Color Mix Strip, preserving all code examples.

assistant: # Color Mix Strip

The *Color Mix* effect strip mixes two strips by working on
the individual and corresponding pixels of the two input strips.

This effect can do the exact same operation as the Add, Subtract,
or Multiply effect strips but also other color blending modes.
user: Provide the full official documentation entry for Bpy.Types.Geometrynodestringtocurves, preserving all code examples.

assistant: lass Node.bl_rna_get_subclass_py NodeInternal.poll NodeInternal.poll_instance NodeInternal.update NodeInternal.draw_buttons NodeInternal.draw_buttons_ext NodeInternal.bl_rna_get_subclass NodeInternal.bl_rna_get_subclass_py GeometryNode.poll GeometryNode.bl_rna_get_subclass GeometryNode.bl_rna_get_subclass_py Next GeometryNodeSubdivideCurve(GeometryNode) Previous GeometryNodeStringJoin(GeometryNode) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page GeometryNodeStringToCurves(GeometryNode) GeometryNodeStringToCurves GeometryNodeStringToCurves.align_x GeometryNodeStringToCurves.align_y GeometryNodeStringToCurves.font GeometryNodeStringToCurves.overflow GeometryNodeStringToCurves.pivot_mode GeometryNodeStringToCurves.is_registered_node_type() GeometryNodeStringToCurves.input_template() GeometryNodeStringToCurves.output_template() GeometryNodeStringToCurves.bl_rna_get_subclass() GeometryNodeStringToCurves.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Vertex Groups can potentially have a very large number of associated vertices
and thus a large number of weights (one weight per assigned vertex).
*Weight Painting* is a method to maintain large amounts of weight information
in a very intuitive way.

It is primarily used for rigging meshes, where the vertex groups are used to
define the relative bone influences on the mesh. But we use it also for
controlling particle emission, hair density, many modifiers, shape keys, etc.

[image reference removed]

Vertex group in Weight Paint Mode.

You can enter Weight Paint Mode from the Mode selector `Ctrl`-`Tab`.
The selected mesh object is displayed slightly shaded with a rainbow color spectrum.
The color visualizes the weights associated to each vertex in the active vertex group.
By default *blue* means unweighted and *red* means fully weighted.

You can assign weights to the vertices of the object by painting on it with weight brushes.
Starting to paint on a mesh automatically adds weights to the active vertex group
(a new vertex group is created if needed).

Vertex Groups can be managed in the pallette pop-over in the middle of the header.
user: Provide the full official documentation entry for Lighting, preserving all code examples.

assistant: # Lighting

The Workbench engine does not use the lights of the scene.
The lighting conditions that will be used can be set in the Lighting panel.

Flat:
:   Objects are “shaded” in a flat color, without any highlights or shadows.

Studio:
:   Use a predefined studio lighting setup, such as a key light
    shining from the front and a rim light shining from the back.
    Click the sphere to choose a different setup.

    The studio lights can be configured in the [Preferences](../../editors/preferences/lights.xhtml#prefs-lights-studio).
    By default, they follow the viewport camera around, but this can be changed:

    World Space Lighting
    :   Keep the lights fixed in place rather than following the viewport camera.

    Rotation
    :   The rotation of the lights on the Z axis.

MatCap:
:   Use a Material Capture, which is an image with texturing, lighting
    and even reflections baked into it. Objects are shaded by
    simply picking colors from this image based on the direction of
    the normal in relation to the camera.

    Click the sphere to choose a different MatCap,
    or the double arrow button to flip it horizontally.

    Custom MatCaps can be loaded in the [Preferences](../../editors/preferences/lights.xhtml#prefs-lights-matcaps).
user: Show practical ways to work with Select More/Less in a Blender add-on or script – include code.

assistant: # Select More/Less

With at least one vertex, edge, or face selected, *Select More/Less* expands or shrinks the selection.
However, if there is only one selection in any selection mode, *Less* will deselect it.

Face Step
:   With *Face Step* on, each use of the tool
    will affect the size of the selection on a face by face basis.
    When deactivated, it will be based on either vertices or edges depending on which
    [Selection Mode](introduction.xhtml) is active.

[image reference removed]

(From left to right) initial selection, without Face Step,
with Face Step, and in edge selection mode.
user: Show practical ways to work with Sheen BSDF in a Blender add-on or script – include code.

assistant: # Sheen BSDF

[image reference removed]

Cycles Only

The *Sheen* BSDF
is used to add reflection to materials that have micro surface details such as cloth or dust.
This shader is intended to be layered on top of other shaders such as
[dielectric](../../../glossary/index.html#term-Dielectric-Material) or metallic shader setups.
user: Show practical ways to work with KeyingSetPaths(bpy_struct) in a Blender add-on or script – include code.

assistant: # KeyingSetPaths(bpy_struct)

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

*class* bpy.types.KeyingSetPaths(*bpy_struct*)
:   Collection of keying set paths

    active
    :   Active Keying Set used to insert/delete keyframes

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

    active_index
    :   Current Keying Set index

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

    add(*target_id*, *data_path*, *\**, *index=-1*, *group_method='KEYINGSET'*, *group_name=''*)
    :   Add a new path for the Keying Set

        Parameters:
        :   - **target_id** ([`ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")) – Target ID, ID data-block for the destination
            - **data_path** (*string**,* *(**never None**)*) – Data-Path, RNA-Path to destination property
            - **index** (*int in* *[**-1**,* *inf**]**,* *(**optional**)*) – Index, The index of the destination property (i.e. axis of Location/Rotation/etc.), or -1 for the entire array
            - **group_method** (enum in [Keyingset Path Grouping Items](bpy_types_enum_items/keyingset_path_grouping_items.html#rna-enum-keyingset-path-grouping-items), (optional)) – Grouping Method, Method used to define which Group-name to use
            - **group_name** (*string**,* *(**optional**,* *never None**)*) – Group Name, Name of Action Group to assign destination to (only if grouping mode is to use this name)

        Returns:
        :   New Path, Path created and added to the Keying Set

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

    remove(*path*)
    :   Remove the given path from the Keying Set

        Parameters:
        :   **path** ([`KeyingSetPath`](bpy.types.KeyingSetPath.html#bpy.types.KeyingSetPath "bpy.types.KeyingSetPath"), (never None)) – Path

    clear()
    :   Remove all the paths from the Keying Set

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

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

1. Open Blender and go to [Add-ons](../../editors/preferences/addons.xhtml) section of the [Preferences](../../editors/preferences/index.xhtml).
2. Search “glTF 2.0” and check the *Enable Add-on* checkbox.
user: Explain Select More/Less in complete detail according to the official Blender documentation.

assistant: Parent `[`, Child `]`
:   You can deselect the active bone and select its immediate parent or one of its children.

Extend Parent `Shift`-`[`, Extend Child `Shift`-`]`
:   Similar to *Parent*/*Child* but it keeps the active bone in the selection.
user: Show practical ways to work with VolumeDisplaceModifier(Modifier) in a Blender add-on or script – include code.

assistant: # VolumeDisplaceModifier(Modifier)

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

*class* bpy.types.VolumeDisplaceModifier(*Modifier*)
:   strength
    :   Strength of the displacement

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

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

    texture_map_mode
    :   - `LOCAL`
          Local – Use the local coordinate system for the texture coordinates.
        - `GLOBAL`
          Global – Use the global coordinate system for the texture coordinates.
        - `OBJECT`
          Object – Use the linked object’s local coordinate system for the texture coordinates.

        Type:
        :   enum in [`'LOCAL'`, `'GLOBAL'`, `'OBJECT'`], default `'LOCAL'`

    texture_map_object
    :   Object to use for texture mapping

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

    texture_mid_level
    :   Subtracted from the texture color to get a displacement vector

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

    texture_sample_radius
    :   Smaller values result in better performance but might cut off the volume

        Type:
        :   float in [0, inf], default 0.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 References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.particle_settings`](bpy.context.html#bpy.context.particle_settings "bpy.context.particle_settings") - [`BlendData.particles`](bpy.types.BlendData.html#bpy.types.BlendData.particles "bpy.types.BlendData.particles") - [`BlendDataParticles.new`](bpy.types.BlendDataParticles.html#bpy.types.BlendDataParticles.new "bpy.types.BlendDataParticles.new") | - [`BlendDataParticles.remove`](bpy.types.BlendDataParticles.html#bpy.types.BlendDataParticles.remove "bpy.types.BlendDataParticles.remove") - [`ParticleSystem.settings`](bpy.types.ParticleSystem.html#bpy.types.ParticleSystem.settings "bpy.types.ParticleSystem.settings") |
user: Provide the full official documentation entry for Child Of Constraint, preserving all code examples.

assistant: # Child Of Constraint

The *Child Of* constraint transforms an object or bone as though it were a
[child](../../../scene_layout/object/editing/parent.html) of another object or bone.

The main advantage over a regular parent-child relationship is that the
constraint has an animatable *Influence*, which makes it possible to switch
to different parents over time.

This same *Influence* can also be used to mix multiple *Child Of* constraints
and create a weighted average between multiple parents. However, if those parents
are bones, the [Armature Constraint](armature.html) may be a better choice.
user: Show practical ways to work with FCurveModifiers(bpy_struct) in a Blender add-on or script – include code.

assistant: # FCurveModifiers(bpy_struct)

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

*class* bpy.types.FCurveModifiers(*bpy_struct*)
:   Collection of F-Curve Modifiers

    active
    :   Active F-Curve Modifier

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

    new(*type*)
    :   Add a constraint to this object

        Parameters:
        :   **type** (enum in [Fmodifier Type Items](bpy_types_enum_items/fmodifier_type_items.html#rna-enum-fmodifier-type-items)) – Constraint type to add

        Returns:
        :   New fmodifier

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

    remove(*modifier*)
    :   Remove a modifier from this F-Curve

        Parameters:
        :   **modifier** ([`FModifier`](bpy.types.FModifier.html#bpy.types.FModifier "bpy.types.FModifier"), (never None)) – Removed modifier

    *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 Float2Attribute(Attribute): syntax, arguments, return values, common patterns.

assistant: # Float2Attribute(Attribute)

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

*class* bpy.types.Float2Attribute(*Attribute*)
:   Geometry attribute that stores floating-point 2D vectors

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for BoidState(bpy_struct), preserving all code examples.

assistant: # BoidState(bpy_struct)

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

*class* bpy.types.BoidState(*bpy_struct*)
:   Boid state for boid physics

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

    active_boid_rule_index
    :   Type:
        :   int in [0, inf], default 0

    falloff
    :   Type:
        :   float in [0, 10], default 0.0

    name
    :   Boid state name

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

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

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

    ruleset_type
    :   How the rules in the list are evaluated

        - `FUZZY`
          Fuzzy – Rules are gone through top to bottom (only the first rule which effect is above fuzziness threshold is evaluated).
        - `RANDOM`
          Random – A random rule is selected for each boid.
        - `AVERAGE`
          Average – All rules are averaged.

        Type:
        :   enum in [`'FUZZY'`, `'RANDOM'`, `'AVERAGE'`], default `'FUZZY'`

    volume
    :   Type:
        :   float in [0, 100], default 0.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