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

assistant: Distorted geometry can cause problems since the triangulation of a distorted n-gon is undefined.

Distortion is measured by faces which are not flat,
with parts of the face pointing in different directions.

Minimum/Maximum
:   Minimum/Maximum distortion to display.

[[image reference removed]](../../_images/modeling_meshes_mesh-analysis_distortion.png)

Distorted Faces.
user: How do I use Mesh Access in Blender? Include parameters, examples, warnings and best practices.

assistant: There are two ways to access BMesh data, you can create a new BMesh by converting a mesh from
[`bpy.types.BlendData.meshes`](bpy.types.BlendData.html#bpy.types.BlendData.meshes "bpy.types.BlendData.meshes") or by accessing the current Edit-Mode mesh.
See: `bmesh.types.BMesh.from_mesh` and [`bmesh.from_edit_mesh`](#bmesh.from_edit_mesh "bmesh.from_edit_mesh") respectively.

When explicitly converting from mesh data Python **owns** the data, that means that
the mesh only exists while Python holds a reference to it.
The script is responsible for putting it back into a mesh data-block when the edits are done.

Note that unlike `bpy`, a BMesh does not necessarily correspond to data in the currently open blend-file,
a BMesh can be created, edited and freed without the user ever seeing or having access to it.
Unlike Edit-Mode, the BMesh module can use multiple BMesh instances at once.

Take care when dealing with multiple BMesh instances since the mesh data can use a lot of memory.
While a mesh that the Python script owns will be freed when the script holds no references to it,
it’s good practice to call `bmesh.types.BMesh.free` which will remove all the mesh data immediately
and disable further access.

### Edit-Mode Tessellation

When writing scripts that operate on Edit-Mode data you will normally want to re-calculate the tessellation after
running the script, this needs to be called explicitly.
The BMesh itself does not store the triangulated faces, instead they are stored in the [`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh"),
to refresh tessellation triangles call [`bpy.types.Mesh.calc_loop_triangles`](bpy.types.Mesh.html#bpy.types.Mesh.calc_loop_triangles "bpy.types.Mesh.calc_loop_triangles").
user: Explain NodeTreeInterfaceSocketVector4D(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketVector4D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVector4D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: By default, the node has no input sockets.
Sockets appear when outputs are defined for the node group in the *Group* tab of the sidebar
(or when dragging a connection onto the blank socket area).

Each input corresponds to a group output socket that can be exposed to the parent node tree.
user: How do I use LineStyleThicknessModifier_Calligraphy(LineStyleThicknessModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleThicknessModifier_Calligraphy(LineStyleThicknessModifier)

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

*class* bpy.types.LineStyleThicknessModifier_Calligraphy(*LineStyleThicknessModifier*)
:   Change line thickness so that stroke looks like made with a calligraphic pen

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

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    orientation
    :   Angle of the main direction

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

    thickness_max
    :   Maximum thickness in the main direction

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

    thickness_min
    :   Minimum thickness in the direction perpendicular to the main direction

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

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleThicknessModifier_Calligraphy.type "bpy.types.LineStyleThicknessModifier_Calligraphy.type")
user: What is Set Caps and how is it used in Blender Python scripting?

assistant: Toggle ending cap styles of the stroke.

Rounded
:   Sets stroke start and end points to rounded (default).

Flat
:   Toggle stroke start and end points caps to flat or rounded.

Toggle Start
:   Toggle stroke start point cap to flat or rounded.

Toggle End
:   Toggle stroke end point cap to flat or rounded.

|  |  |  |
| --- | --- | --- |
| <../../../_images/grease-pencil_modes_edit_stroke-menu_cap-1.png>   Stroke ending with rounded caps. | <../../../_images/grease-pencil_modes_edit_stroke-menu_cap-2.png>   Stroke ending with flat caps. | <../../../_images/grease-pencil_modes_edit_stroke-menu_cap-3.png>   Stroke ending with combined caps. |
user: How do I use Surface Deform Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Surface Deform Modifier

The *Surface Deform* modifier allows an arbitrary mesh surface to
control the deformation of another, essentially transferring its motion/deformation.
One great use for this is to have a proxy mesh for cloth simulation,
which will in turn drive the motion of your final and more detailed mesh,
which would otherwise not be suitable for simulation.
user: Explain Access Token in complete detail according to the official Blender documentation.

assistant: Some repositories may require authentication. The user can specify an `access token` for a repository,
which is passed along with the API request from Blender.

This is passed to the servers via an Authorization header:

```
curl -i https://extensions.blender.org/api/v1/extensions/ \
     -H "Accept: application/json" \
     -H "Authorization: Bearer abc29832befb92983423abcaef93001"
```
user: Give a detailed overview of Convert to Mesh Plane: syntax, arguments, return values, common patterns.

assistant: Converts the selected [image empty](../../../modeling/empties.html#bpy-types-object-empty-image) to a textured mesh plane.

For a description of the options see [Mesh Plane](../../../modeling/meshes/import_images_as_planes.html).
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Masks can be created in the *Image* and *Movie Clip* editors, by changing the mode to *Mask* in the header.
This will add various tools and properties to the editor panels,
while hiding others that are not needed for interacting with masks.

Masks have many purposes. They can be used in a motion tracking workflow to mask out,
or influence a particular object in the footage.
They can be used for manual rotoscoping to pull a particular object out of the footage,
or as a rough matte for green-screen keying. Masks are independent from a particular image of movie clip,
and so they can just as well be used for creating motion graphics or other effects in the Compositor.

[image reference removed]

Using the Mask node to isolate an object in compositing.

While the *Movie Clip Editor* and *Image Editor* are used to edit masks,
the *Compositor* and *Sequencer* are just using already created mask.

Masks can be animated over the time so that they follow some object from the footage,
e.g. a running actor. This can be achieved with shape keys or parenting the mask to tracking markers.
user: Show practical ways to work with Crease in a Blender add-on or script – include code.

assistant: # Crease

Create sharp indents or ridges by pushing or pulling the mesh, while pinching the vertices together.

Crease can also be used to sharpen and polish existing creases.
Enable pressure sensitivity on Strength to regulate the add/subtract effect while pinching creases.
user: What is Screw Modifier and how is it used in Blender Python scripting?

assistant: # Screw Modifier

The *Screw* modifier is similar to the [Screw](../../meshes/editing/edge/screw.xhtml) tool
in the Toolbar, in that it takes a profile object, a mesh or a curve, to create a helix-like shape.

[image reference removed]

Properly aligning the profile object is important.

The profile should be properly aligned to the cardinal direction of the object rather than to the screw axis.
user: Describe GeometryNodeGroup(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeGroup(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.GeometryNodeGroup(*GeometryNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Emission

[image reference removed]

Hair particle system settings.

Number
:   Sets the amount of hair strands. Use as few particles as possible
    (especially if you plan to use soft body animation later),
    but still enough to cover the surface and have good control.
    A few thousand particles is generally enough for a regular haircut.
    The hair will be made denser later on using
    [Children](../emitter/children.xhtml).

Hair Length
:   Controls the length of the hair.
user: Show practical ways to work with Particle System Panel in a Blender add-on or script – include code.

assistant: # Particle System Panel

[image reference removed]

Particle System panel.

These are the basic settings.

Active Particle System
:   The [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) of the objects Particle Modifier(s).

    Specials
    :   Copy Active to Selected Objects
        :   Copies the active particle system to all selected objects.

        Copy All to Selected Objects
        :   Copies all particle systems from the active object to all selected objects.

        Duplicate Particle Systems
        :   Duplicates the particle system within the active object.
            The *Duplicate Settings* option (in the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel) will duplicate
            settings as well, so the new particle system uses its own settings.

        Remove All Particle Systems
        :   Remove all particle system within the active object.

Particle Settings
:   The [Data-Block menu](../../interface/controls/templates/data_block.xhtml#ui-data-block) for settings.

Type
:   Main selector of the system type.

    Emitter
    :   In such a system, particles are [emitted](emitter/index.xhtml) from the object.

    Hair
    :   Use [Hair](hair/index.xhtml) type, rendered as strands.

        Regrow
        :   Regrows the hair for each frame. This is useful when you are animating properties.

        Advanced
        :   Enables advanced settings which reflect the same ones as working in Emitter mode.

        Segments
        :   Controls the number of parts a hair is made of.
            Increasing this value will improve the quality of animations.
user: How do I use Clear in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Before

Deletes all tracked and keyframed markers after the current frame for all selected tracks.

Clear Active
:   Limits clear action to only active track (as opposite to all selected ones).

### After

Deletes all tracked and keyframed markers before the current frame for all selected tracks.

Clear Active
:   Limits clear action to only active track (as opposite to all selected ones).

### Track Path

Clears all markers except the current one from all selected tracks.

Clear Active
:   Limits clear action to only active track (as opposite to all selected ones).

### Clear Solution
user: Provide the full official documentation entry for The Simple Case, preserving all code examples.

assistant: Whenever the camera is basically fixed, or at least “almost” stationary, and the footage is crisp and
without motion blur, perfect stabilization is easy to achieve. This might be the case when a tripod was used,
but wind or vibrations on the floor (e.g. on a stage) caused some minor shakes.
Shoulder camera shots done by an experienced operator also frequently fall into this category.

- Use as few points as possible. Start with a single point right on the main subject.
- Track this single point as accurate as possible. Beware of movements and shape changes of the tracked feature.
  Proceed in small increments (e.g. 50 frames), zoom in and readjust the target point manually when it drifts away.
  Another option is to use a larger target area for tracking; since we’re tracking only a single point,
  the slower tracking speed might be acceptable.
- After enabling the basic (location) stabilization, consider if you really need rotation stabilization.
  Often, some minor, slow swinging movements are not really noticeable and do not warrant the additional working time
  and quality loss caused by rotation and scale stabilization.
- For rotation, start with one extra point, well spaced but preferably still attached to the main subject.
- Consider to fix some slow residual motion by manually animating the “*Expected* \*” parameters,
  before you even think of adding more tracking markers. Because doing so is often not worth the effort.
- If you need to add more points, the most important goal is to achieve *symmetry.*
  Place location tracking points symmetrically above and below the horizon.
  Place rotation tracking points into diagonally opposed direction, always centered around the main focal area.
user: Show practical ways to work with Field Context in a Blender add-on or script – include code.

assistant: All field nodes work in the context of the data flow node they are connected to.
The context usually consists of a geometry component type and an attribute domain,
so it determines what data is retrieved from input nodes.

One common misunderstanding is that the same field node tree used in multiple places will
output the same data. This is not necessarily true, because the field node tree will be evaluated
for every data flow node, potentially retrieving data from a different or changed geometry.

[image reference removed]

Here, the [Set Position](geometry/write/set_position.xhtml) node’s
input field is evaluated once. To evaluate the field, the node traverses
backwards to retrieve the inputs from the field input nodes.

[image reference removed]

When a second Set Position node is added, the same field node tree is evaluated twice, once for each data flow node.
At the second Set Position node, the results will be different since its geometry input will already have
the changed position from the first node.

[image reference removed]

However, often it’s necessary to use the same field values even after changing the geometry.
The [Capture Attribute Node](attribute/capture_attribute.xhtml) evaluates a field, copying
the result to an [anonymous attribute](attributes_reference.xhtml#anonymous-attributes) on the geometry.

Here, a Capture Attribute node stores a copy of the initial position.
Notice that evaluating the field input of the Capture Attribute node is an entirely
different step. Later on, the input fields to the Set Position nodes don’t use
the actual position, but the anonymous attribute copy of it.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.generation_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items "bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items") - [`NodeGeometryForeachGeometryElementGenerationItems.new`](bpy.types.NodeGeometryForeachGeometryElementGenerationItems.html#bpy.types.NodeGeometryForeachGeometryElementGenerationItems.new "bpy.types.NodeGeometryForeachGeometryElementGenerationItems.new") | - [`NodeGeometryForeachGeometryElementGenerationItems.remove`](bpy.types.NodeGeometryForeachGeometryElementGenerationItems.html#bpy.types.NodeGeometryForeachGeometryElementGenerationItems.remove "bpy.types.NodeGeometryForeachGeometryElementGenerationItems.remove") |
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Transform Space
:   The transformation of the vector and geometry outputs.

    Original:
    :   Output the geometry relative to the input object transform, and the location,
        rotation and scale relative to the world origin.

    Relative:
    :   Bring the input object geometry, location, rotation and scale into the modified object,
        maintaining the relative position between the two objects in the scene.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Transform Cache Constraint.

Cache File
:   Data-block menu to select the Alembic or USD file.

File Path
:   Path to the Alembic or USD file.

Sequence
:   Whether or not the cache is separated in a series of files.

Override Frame
:   Whether to use a custom frame for looking up data in the cache file,
    instead of using the current scene frame.

    The *Frame* value is the time to use for looking up the data in the cache file,
    or to determine which to use in a file sequence.

Frame Offset
:   Subtracted from the current frame to use for looking up the data in the cache file,
    or to determine which file to use in a file sequence.

Manual Scale
:   Value by which to enlarge or shrink the object with respect to the world’s origin.

Velocity Attribute
:   The name of the Alembic attribute used for generating motion blur data;
    by default, this is `.velocities` which is standard for most Alembic files.

Velocity Unit
:   Defines how the velocity vectors are interpreted with regard to time.

    Frame:
    :   The velocity unit was encoded in frames and does not need to be scaled by scene FPS.

    Second:
    :   The velocity unit was encoded in seconds and needs to be scaled by the scene FPS (1 / FPS).

Object Path
:   The path to the Alembic or USD object inside the archive or stage.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the object.
user: How do I use Convert to Display Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Convert to Display Node

[image reference removed]

The *Convert to Display* node applies an [OpenColorIO](../../../render/color_management/opencolorio.xhtml)
[display, view, and look transform](../../../render/color_management/displays_views.xhtml)
to an image in the *scene linear* color space.
It converts linear render data into a color-accurate representation for a specific display and view
combination, following the configuration defined in the active color management settings.

This node complements the [Convert Colorspace](convert_colorspace.xhtml) node
by supporting display-view-look combinations, which are not represented as individual color spaces
in modern OCIO configurations.
Unlike *Convert Colorspace*, this node reproduces the same color management transforms used by
the *Save As Render* option or the *Render View* display.
user: Explain MeshLoops(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # MeshLoops(bpy_struct)

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

*class* bpy.types.MeshLoops(*bpy_struct*)
:   Collection of mesh loops

    add(*count*)
    :   add

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Count, Number of loops to add

    *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 Outputs, preserving all code examples.

assistant: Index
:   The [index](../read/input_index.xhtml)
    of the closest element in the same geometry component.

Has Neighbor
:   This is true when the group of the element has at least two elements.
    This is only relevant when using *Group ID*.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Mode
:   The location to load the IES file from.

    Internal:
    :   Use IES profile from a file embedded in a text data-block in the blend-file, for easy distribution.

    External:
    :   Load IES profile from a file on the drive.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

The node can be used to round the corners of simple 3D poly splines.

[image reference removed]

The node can be combined with the curve primitive nodes to make more interesting shapes.
user: Describe Presets from the Blender manual or Python API, including usage steps and snippets.

assistant: At the top of the window, you can select and manage presets.

Keymap Presets
:   The selector lets you choose from builtin presets:

    - [Blender](../../interface/keymap/blender_default.xhtml): the default keymap,
      which is the one used throughout this manual.
    - Blender 27x: legacy keymap as used in Blender 2.79 and before.
    - [Industry Compatible](../../interface/keymap/industry_compatible.xhtml): a keymap
      which more closely matches other 3D editing applications.

Add Custom Keymap Configuration
:   Add a custom keymap configuration.

Remove Keymap Configuration
:   Remove a custom keymap configuration.

Import
:   Opens a File Browser to select a `.py` file containing a custom preset.

Export
:   Saves the current keymap configuration as a preset others may use.

    All Keymaps
    :   When disabled, only the shortcut assignments that have been modified will be exported.
        This exported file may be thought of as a “keymap delta” instead of a full export.

        When enabled, the entire keymap is written.
user: What is Is UV Split Node and how is it used in Blender Python scripting?

assistant: # Is UV Split Node

[image reference removed]

The *Is UV Split* node outputs a selection indicating which edges in a mesh are *UV splits*.
A UV split occurs when an edge connects two faces that use different UV coordinates along that edge,
causing a discontinuity in the UV map.

This node is useful for detecting UV seams, isolating edges used for UV islands, or
creating procedural operations that depend on UV boundaries.
user: Give a detailed overview of Compatibility: syntax, arguments, return values, common patterns.

assistant: In some cases, Blender may crash on startup. Running Blender in compatibility mode can help in fixing this issue. To
enable compatibility mode, `RMB` on the Blender executable and select Properties ‣
Compatibility and enable Run this program in compatibility mode. Confirm the changes with *Apply*.
user: Describe Default Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: - The **Edit** scene has a default length of **10 seconds**, providing a concise overview of
  the full storyboard sequence.
- Each **shot scene** is set to **2 seconds** by default, offering a shorter duration that makes
  it easier to visualize pacing in the Sequencer.
- Frame ranges are shortened compared to typical defaults (e.g., 250 frames) to make timeline
  navigation more practical for storyboard editing.
user: Describe FunctionNodeStringLength(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeStringLength(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.FunctionNodeStringLength(*FunctionNode*)
:   Output the number of characters in the given string

    *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 Examples, preserving all code examples.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_transparent_example.jpg   Transparent shader (pure white). | ../../../_images/render_shader-nodes_shader_transparent_behavior.svg   Transparent shader behavior. |
| ../../../_images/render_shader-nodes_shader_transparent_example-dark.jpg   Transparent shader (gray). |  |
user: What is UV Maps and how is it used in Blender Python scripting?

assistant: If you have a mesh object selected, you’ll find its UV maps in the Data tab of the
[Properties editor](../../../editors/properties_editor.xhtml). After selecting a map,
you can view and edit it in the [UV editor](../../../editors/uv/introduction.xhtml).

One mesh can have multiple UV maps (e.g. one map per texture), although it’s
also possible to reuse a UV map for multiple textures.

[image reference removed]

The UV Maps panel in the Data tab.

/ Active Render
:   Marks the UV map as the the default one for rendering. The *Active Render* UV map is used for:

    - The [UV Pass](../../../render/layers/passes.xhtml#bpy-types-viewlayer-use-pass-uv) for compositing
    - The [Texture Coordinate Node](../../../render/shader_nodes/input/texture_coordinate.xhtml) for material shading.
    - The [UV Map Node](../../../render/shader_nodes/input/uv_map.xhtml) for material shading when no UV map is specified.

Add UV Map
:   Duplicates the selected UV map, or creates a new one if the list is empty.

Remove UV Map
:   Removes the selected UV map.
user: How do I use Further Options in Blender? Include parameters, examples, warnings and best practices.

assistant: R, G, B
:   Tracking happens in gray-scale space, so a high contrast between the feature and
    its background yields more accurate tracking.
    In such cases disabling some color channels can help.

Grayscale Preview (B/W)
:   Display the preview image as gray-scale even if all channels are enabled.

Alpha
:   Applies mask defined by an annotation tool in the preview widget.

Weight
:   When several tracks are used for 3D camera reconstruction, it is possible to assign
    a reduced weight to some tracks to control their influence on the solution result.
    This parameter can (and often need to) be animated.

    Altering the weights of problem tracking markers can correct or greatly reduce undesirable jumps
    as feature disappear or become difficult to track.

    Another use of Track Weights is when you want to reconstruct a scene from your camera solution.
    In that case you can first carefully track and solve your scene, and once you are done,
    lock all your markers with `Ctrl`-`L`, set the tracker weight in the Extra Settings of
    the tracker settings to zero and use the feature detection to quickly add lots of markers.
    Now track them and solve the scene again. Since their weight is zero
    they will not influence your solution at all, but you will have lots of good reference points in your scene.

Stabilization Weight
:   While *Weight* parameter is used for 3D reconstruction,
    the *Stabilization Weight* is used to control 2D stabilization.

Custom Color Presets
:   The preset for the *Custom Color*.

Custom Color
:   This setting overrides the default marker color used in the Clip editor and 3D Viewport,
    and it helps to distinguish different type of features
    (for example, features in the background vs. foreground and so on).
    Color also can be used for “grouping” tracks so a whole group of tracks can be selected by
    color using the Select Grouped operator.
user: Describe Extrude Region from the Blender manual or Python API, including usage steps and snippets.

assistant: # Extrude Region

Extrusion tools duplicate vertices, while keeping the new geometry connected with the original vertices.
Vertices are turned into edges and edges will form faces.

|  |  |
| --- | --- |
| ../../../_images/modeling_meshes_tools_extrude-region_vert.png   Single vertex extruded. | ../../../_images/modeling_meshes_tools_extrude-region_edge.png   Single edge extruded. |

This tool is of paramount importance for creating new geometry.
It allows you to create parallelepipeds from rectangles and cylinders from circles,
as well as easily creating such things as tree limbs.

The axis on which vertices and edges are extruded along can be set interactively.
Faces are extruded by default along their averaged normal.
The extrusion can be limited to a single axis by specifying an axis;
see [Axis Locking](../../../scene_layout/object/editing/transform/control/axis_locking.xhtml).

The extrude tools differentiate in how the new geometry is connected in itself.

Only the border loop gets extruded.
The inner region of the selection gets moved unchanged with the extrusion.

|  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_meshes_tools_extrude-region_face-before.png   Selected face. | ../../../_images/modeling_meshes_tools_extrude-region_face-after.png   During extrude. | ../../../_images/modeling_meshes_tools_extrude-region_face-after-zaxis.png   Set to Z axis. |
user: Give a detailed overview of Index Buffers: syntax, arguments, return values, common patterns.

assistant: Often triangles and lines share one or more vertices.
With only a vertex buffer one would have to store all attributes for the these vertices multiple times.
This is very inefficient because in a connected triangle mesh every vertex is used 6 times on average.
A more efficient approach would be to use an *Index Buffer* (IBO) ([`gpu.types.GPUIndexBuf`](gpu.types.html#gpu.types.GPUIndexBuf "gpu.types.GPUIndexBuf")),
sometimes referred to as *Element Buffer*.
An *Index Buffer* is an array that references vertices based on their index in the vertex buffer.

For instance, to draw a rectangle composed of two triangles, one could use an index buffer.

```
positions = (
    (-1,  1), (1,  1),
    (-1, -1), (1, -1))

indices = ((0, 1, 2), (2, 1, 3))

ibo = gpu.types.GPUIndexBuf(type='TRIS', seq=indices)
```

Here the first tuple in `indices` describes which vertices should be used for the first triangle
(same for the second tuple).
Note how the diagonal vertices 1 and 2 are shared between both triangles.
user: Give a detailed overview of Getting Started: syntax, arguments, return values, common patterns.

assistant: To begin compositing, open the *Compositor* and create a new node tree
by clicking the [New](../editors/compositor.xhtml#bpy-ops-node-new-compositing-node-group) button in the header.
This adds a compositing node tree data block to the scene, which can then be reused
across different scenes or linked/appended from other blend-files.

Once a node tree is created, you will see your first basic setup.
From here you can add and connect many types of
[Compositing Nodes](index.xhtml) in a node graph layout
to build effects ranging from simple color corrections to complex composites.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`PreferencesSystem.solid_lights`](bpy.types.PreferencesSystem.html#bpy.types.PreferencesSystem.solid_lights "bpy.types.PreferencesSystem.solid_lights") | - [`StudioLight.solid_lights`](bpy.types.StudioLight.html#bpy.types.StudioLight.solid_lights "bpy.types.StudioLight.solid_lights") |
user: Explain Select Random in complete detail according to the official Blender documentation.

assistant: Randomly selects unselected points or strokes.

Ratio
:   The likelihood of an unselected elements being selected.
    Note that, this is not the percentage amount of elements that will be selected.

Random Seed
:   [Seed](../../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

Action
:   Selection or deselection of elements.
user: Show practical ways to work with Tools for Scene Orientation and Stabilization in a Blender add-on or script – include code.

assistant: After solve, you need to orient the real scene in the 3D scene for more convenient compositing.
There are tools to define the floor, the scene origin, and the X/Y axes to perform scene orientation.

Sometimes, the video footage includes spurious jumps and tilting movements, like e.g. when using a hand-held camera.
Based on some tracked image elements,
the [2D Stabilization](clip/sidebar/stabilization/index.xhtml)
is able to detect and compensate such movements to improve the quality of the final result.
user: Provide the full official documentation entry for FunctionNodeTransformPoint(FunctionNode), preserving all code examples.

assistant: # FunctionNodeTransformPoint(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.FunctionNodeTransformPoint(*FunctionNode*)
:   Apply a transformation matrix to the given vector

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Options and how is it used in Blender Python scripting?

assistant: Fluid physics share options with [Newtonian Physics](newtonian.xhtml).
These are covered on that page.

### Fluid Properties

Stiffness
:   How incompressible the fluid is.

Viscosity
:   Linear viscosity. Use lower viscosity for thicker fluids.

Buoyancy
:   Artificial buoyancy force in negative gravity direction based on pressure differences inside the fluid.

### Advanced

Repulsion Factor
:   How strongly the fluid tries to keep from clustering (factor of stiffness).
    Checkbox sets repulsion as a factor of stiffness.

Stiff Viscosity
:   Creates viscosity for expanding fluid. Checkbox sets this to be a factor of normal viscosity.

Interaction Radius
:   Fluid’s interaction radius. Checkbox sets this to be a factor of 4 × *particle size*.

Rest Density
:   Density of fluid when at rest. Checkbox sets this to be a factor of default density.

### Springs

Force
:   Spring force.

Rest Length
:   Rest length of springs. Factor of particle radius. Checkbox sets this to be a factor of 2 × *particle size*.

Viscoelastic Springs
:   Use viscoelastic springs instead of Hooke’s springs.

Elastic Limit
:   How much the spring has to be stretched/compressed in order to change its rest length.

Plasticity
:   How much the spring rest length can change after the elastic limit is crossed.

Initial Rest Length
:   Use initial length as spring rest length instead of 2 × *particle size*.

Frames
:   Create springs for this number of frames since particle’s birth (0 is always).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input image.

Luminance Noise
:   Controls the amount of brightness variation (value noise) applied to the image.
    Higher values create stronger light and dark fluctuations, similar to high ISO noise.

Chroma Noise
:   Controls the amount of color noise added to the image.
    Higher values introduce visible color speckling, typical of low-light digital images.

Animated
:   When enabled, generates a new noise pattern on each frame, mimicking real sensor noise.
    When disabled, the noise remains static across frames.
user: Provide the full official documentation entry for Properties, preserving all code examples.

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

    1D:
    :   The *W* input is used as seed.

    2D:
    :   The X and Y components of the *Vector* input are used as seed.

    3D:
    :   The *Vector* input is used as seed.

    4D:
    :   Both the *Vector* input and the *W* input are used as seed.
user: Describe Fluid Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Fluid Modifier

The Fluid modifier is a container for a [Fluid Physics](../../../physics/fluid/index.xhtml) simulation. It can be useful
for example, to simulate on a low-poly mesh then add a [Subdivision Surface Modifier](../generate/subdivision_surface.xhtml)
after the Fluid modifier to improve the visual quality of the fluid without drastically increasing simulation times.
user: Show practical ways to work with CompositorNodeBlur(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeBlur(CompositorNode)

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

*class* bpy.types.CompositorNodeBlur(*CompositorNode*)
:   Blur an image, using several blur modes

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Color
:   Tint for AO output color.

Distance
:   Distance up to which other objects are considered to occlude the shading point.

Normal
:   Normal used for ambient occlusion; if nothing is connected the default shading normal is used.