PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is LineStyleAlphaModifier_CreaseAngle(LineStyleAlphaModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleAlphaModifier_CreaseAngle(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_CreaseAngle(*LineStyleAlphaModifier*)
:   Alpha transparency based on the angle between two adjacent faces

    angle_max
    :   Maximum angle to modify thickness

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

    angle_min
    :   Minimum angle to modify thickness

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

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

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

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

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

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

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

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

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # NodeSocketVector(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVector(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Lattice properties.

Lattice
:   A [Data-Block Menu](../interface/controls/templates/data_block.html#ui-data-block).

### Lattice

Points
:   Rate of subdivision in the axes:

    U, V, W

Interpolation Type
:   Selector for each axis. See [Different types of interpolation.](shape_keys/shape_keys_panel.html#fig-interpolation-type).

    Linear, Cardinal, Catmull-Rom, B-Spline

Outside
:   Takes only the vertices on the surface of the lattice into account.

Vertex Group
:   The strength of the influence assigned as a weight to the individual vertices in the selected vertex group.
user: Provide the full official documentation entry for Trying the Make Process to Create HTML Files in English, preserving all code examples.

assistant: 1. Ensure the previous instance of `build` directory is removed, if any exists:

   ```
   make clean
   ```
2. Convert all the `rst` files into `pot` translation files:

   ```
   make gettext
   ```
3. Create `html` files:

   ```
   make html
   ```
4. After this, you can actually view the created html files locally
   by opening the `blender-manual/build/html/index.html` file.
user: What is Usage and how is it used in Blender Python scripting?

assistant: For the most part using Blender as a Python module is equivalent to running a script in background-mode
(passing the command-line arguments `--background` or `-b`),
however there are some differences to be aware of.

Blender’s Executable Access
:   The attribute [`bpy.app.binary_path`](bpy.app.html#bpy.app.binary_path "bpy.app.binary_path") defaults to an empty string.

    If you wish to point this to the location of a known executable you may set the value.

    This example searches for the binary, setting it when found:

    ```
    import bpy
    import shutil

    blender_bin = shutil.which("blender")
    if blender_bin:
       print("Found:", blender_bin)
       bpy.app.binary_path = blender_bin
    else:
       print("Unable to find blender!")
    ```

Blender’s Internal Modules
:   There are many modules included with Blender such as [`gpu`](gpu.html#module-gpu "gpu") and `mathuils`.
    It’s important that these are imported after `bpy` or they will not be found.

Command Line Arguments Unsupported
:   Functionality controlled by command line arguments (shown by calling `blender --help` aren’t accessible).

    Typically this isn’t such a limitation although there are some command line arguments that don’t have
    equivalents in Blender’s Python API (`--threads` and `--log` for example).

Resource Sharing (GPU)
:   It’s possible other Python modules make use of the GPU in a way that prevents Blender/Cycles from accessing the GPU.

Signal Handlers
:   Blender’s typical signal handlers are not initialized, so there is no special handling for `Control-C`
    to cancel a render and a crash log is not written in the event of a crash.

Startup and Preferences
:   When the `bpy` module loads it contains the default startup scene
    (instead of an “empty” blend-file as you might expect), so there is a default cube, camera and light.

    If you wish to start from an empty file use: `bpy.ops.wm.read_factory_settings(use_empty=True)`.

    The users startup and preferences are ignored to prevent your local configuration from impacting scripts behavior.
    The Python module behaves as if `--factory-startup` was passed as a command line argument.

    The users preferences and startup can be loaded using operators:

    ```
    import bpy

    bpy.ops.wm.read_userpref()
    bpy.ops.wm.read_homefile()
    ```
user: Give a detailed overview of Easing Type: syntax, arguments, return values, common patterns.

assistant: Sets the [easing mode](properties.html#editors-graph-fcurves-settings-easing) of the selected keyframes.
This determines whether easing is applied to the left side, right side, or both sides of the
curve segments between each keyframe and the next.
user: How do I use Shortest Edge Paths Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Shortest Edge Paths Node

[image reference removed]

The *Shortest Edge Paths* node finds paths along mesh edges to a selection of end vertices.
The cost used to define “shortest” can be set to anything. By default there is a constant cost
for every edge, but a typical input would be the length of each edge.

The output is encoded with vertex indices, and is meant to be used on the vertex domain.
For each vertex, the *Next Vertex Index* output gives the index of the following vertex
in the path to the “closest” endpoint.

The node is implemented with [Dijkstra’s algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm).
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_glossy_example.jpg   Sharp Glossy example. | ../../../_images/render_shader-nodes_shader_glossy_behavior-sharp.svg   Sharp Glossy behavior. |
| ../../../_images/render_shader-nodes_shader_glossy_rough.jpg   Rough Glossy example. | ../../../_images/render_shader-nodes_shader_glossy_behavior.svg   Rough Glossy behavior. |

[image reference removed]

Anisotropic shading with 0° rotation, 90° rotation and textured rotation of the tangent direction.
[Example blend-file](https://archive.blender.org/wiki/2015/uploads/b/b7/Blender2.65_cycles_anisotropic.blend).
user: Give a detailed overview of Keying Screen Node: syntax, arguments, return values, common patterns.

assistant: # Keying Screen Node

[image reference removed]

The Keying Screen node creates plates for use as a color reference for keying nodes.
It generates gradients from sampled colors on motion tracking points on movie clips.
It can be used to deal with uneven colors of green screens.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   Standard color input.

Samples
:   The number of samples used to compute the blur.
    The more samples the smoother the result, but at the expense of more compute time.
    The actual number of samples is two to the power of this input, so it increases exponentially.

Center
:   The position at which the transformations pivot around.
    Defined in normalized coordinates, so 0 means lower left corner and 1 means upper right corner of the image.

Rotation
:   The amount of rotation that the blur spans.

Scale
:   The amount of scaling that the blur spans.

### Translation

Amount
:   The amount of translation that the blur spans in the specified direction relative to the size of the image.
    Negative values indicate translation in the opposite direction.

Direction
:   The angle that defines the direction of the translation.
user: Give a detailed overview of Duplicate: syntax, arguments, return values, common patterns.

assistant: # Duplicate

This tool simply duplicates the selected elements,
without creating any connections with the rest of the mesh (unlike extrude, for example),
and places the duplicate at the location of the original. Once the duplication is done,
only the *new* duplicated elements are selected,
and you are automatically placed in move mode, so you can move your copy elsewhere…

In the *Toolbar* are settings for *Vector* offset, *Proportional Editing*,
*Duplication Mode*, and *Axis Constraints*.

Note that duplicated elements belong to the same
[vertex groups](../../properties/vertex_groups/index.html) as the “original” ones.
The same goes for the [material indices](../../../../render/materials/assignment.html#bi-multiple-materials),
the edge’s *Sharp* and *Seam* marks, and probably for the other vertex/edge/face properties…
user: What is Layer and how is it used in Blender Python scripting?

assistant: # Layer

This brush is similar to [Draw](clay.xhtml),
except that the height capped.
This creates the appearance of a flat layer.

It is recommended to use the [Persistent](#bpy-types-brush-use-persistent) setting
and regularly [Set Persistent Base](#bpy-ops-sculpt-set-persistent-base),
so that multiple strokes to not add on top of each other.
user: Explain Details in complete detail according to the official Blender documentation.

assistant: Although the process is quite intuitive,
the principles behind *Extrude* are fairly elaborate as discussed below:

- First, the algorithm determines the outside edge loop of the extrude; that is,
  which among the selected edges will be changed into faces. By default (see below),
  the algorithm considers edges belonging to two or more selected faces as internal, and hence not part of the loop.
- The edges in the edge loop are then changed into faces.
- If the edges in the edge loop belong to only one face in the complete mesh,
  then all of the selected faces are duplicated and linked to the newly created faces. For example,
  rectangles will result in parallelepipeds during this stage.
- In other cases, the selected faces are linked to the newly created faces but not duplicated.
  This prevents undesired faces from being retained “inside” the resulting mesh.
  This distinction is extremely important since it ensures the construction of consistently coherent,
  closed volumes at all times when using *Extrude*.
- When extruding completely closed volumes (like e.g. a cube with all its six faces),
  extrusion results merely in a duplication, as the volume is duplicated, without any link to the original one.
- Edges not belonging to selected faces, which form an “open” edge loop,
  are duplicated and a new face is created between the new edge and the original one.
- Single selected vertices which do not belong to selected edges
  are duplicated and a new edge is created between the two.
user: Provide the full official documentation entry for Collection Info Node, preserving all code examples.

assistant: # Collection Info Node

[image reference removed]

The *Collection Info* node gets information from collections.
This can be useful to control parameters in the geometry node tree with an external collection.
user: Describe Batch Creation from the Blender manual or Python API, including usage steps and snippets.

assistant: Batches can be creates by first manually creating VBOs and IBOs.
However, it is recommended to use the [`gpu_extras.batch.batch_for_shader`](gpu_extras.batch.html#gpu_extras.batch.batch_for_shader "gpu_extras.batch.batch_for_shader") function.
It makes sure that all the vertex attributes necessary for a specific shader are provided.
Consequently, the shader has to be passed to the function as well.
When using this function one rarely has to care about the vertex format, VBOs and IBOs created in the background.
This is still something one should know when drawing stuff though.

Since batches can be drawn multiple times, they should be cached and reused whenever possible.
user: Describe Pull Requests from the Blender manual or Python API, including usage steps and snippets.

assistant: # Pull Requests

This page describes the tools used for code contribution and review.

Reviews are a key measure to assure changes are of a good quality. They help preventing bugs, design consistencies, or
potential maintenance problems. And having your work reviewed also generally keeps you on your toes.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Evaluate Closure* node does not have functional properties, but its input and output interface can be managed in
the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the node as defining a closure signature to be used by other closure nodes. Ensures consistent input and output
    definitions across related closures.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click to rename.

Add Item
:   Add a new input socket to the closure interface.

Remove Item
:   Delete the selected input socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../interface/controls/nodes/parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

List of output sockets
:   Displays one entry per output socket. Double-click to rename.

Add Item
:   Add a new output socket to the node.

Remove Item
:   Delete the selected output socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.
user: What is Raycast Node and how is it used in Blender Python scripting?

assistant: # Raycast Node

[image reference removed]

The *Raycast* node intersects rays from one geometry onto another. The source geometry is defined by
the context of the node that the *Raycast* node is connected to.
Each ray computes hit points on the target mesh and outputs normals, distances
and any surface attribute specified.
user: Explain Is Face Planar Node in complete detail according to the official Blender documentation.

assistant: # Is Face Planar Node

[image reference removed]

The *Is Face Planar* node outputs whether every triangle of a
[quads](../../../../glossary/index.xhtml#term-Quad) or [N-gons](../../../../glossary/index.xhtml#term-N-gon) is on the same plane as all of the others, in
other words, if they have the same [normal](../../../meshes/editing/mesh/normals.xhtml).

For example, a non-planar face can be created by moving a single vertex in a face but not
the others. Triangles will always be planar.
user: Give a detailed overview of Color Spill Node: syntax, arguments, return values, common patterns.

assistant: # Color Spill Node

[image reference removed]

The *Color Spill* node is used to suppress unwanted color casts—typically green or blue;
caused by light reflecting from a chroma key (green or blue screen) onto the subject.

This “spill” is common in compositing workflows and can give a subject an unnatural colored tint.
The node reduces the influence of the selected color channel,
removing the excess and restoring a more natural appearance.
user: How do I use Creating Catalogs in Blender? Include parameters, examples, warnings and best practices.

assistant: New catalogs can be created in the [Asset Browser](../../editors/asset_browser.html)
through Header ‣ Catalog ‣ New Asset Catalog.
Once the catalog is created you can double `LMB` on it’s name in the
*Source List* region of the editor to give the catalog a more descriptive name.
Catalogs can also be created in this region by clicking the plus icon found at the top of the tree view.
user: What is Join and how is it used in Blender Python scripting?

assistant: ### Join

Join two or more strokes into a single one.

Type
:   Join:
    :   `Ctrl`-`J`
        Join selected strokes by connecting points.

    Join and Copy:
    :   Join selected strokes by connecting points in a new stroke.

Leave Gaps
:   When enabled, do not use geometry to connect the strokes.

### Join and Copy

Same as [Join](#bpy-ops-grease-pencil-join-selection) but *Type* defaults to *Join and Copy*.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: | Input Value | Round | Floor | Ceiling | Truncate |
| --- | --- | --- | --- | --- |
| -69.6574 | -70 | -70 | -69 | -69 |
| -3.14159 | -3 | -4 | -3 | -3 |
| -1.5 | -2 | -2 | -1 | -1 |
|  |  |  |  |  |
| 1.5 | 2 | 1 | 2 | 1 |
| 3.14159 | 3 | 3 | 4 | 3 |
| 69.6574 | 70 | 69 | 70 | 69 |
user: Give a detailed overview of NURBS: syntax, arguments, return values, common patterns.

assistant: One of the characteristics of a NURBS object is the *knot vector*.
This is a sequence of numbers used to determine the influence of the control points on the curve.
While you cannot edit the knot vectors directly,
you can influence them through the *Endpoint* and *Bézier* options in the Active Spline panel.
Note that, the *Endpoint* and *Bézier* settings only apply to open NURBS curves.

[image reference removed]

Active Spline: NURBS Spline.

Cyclic U
:   See [Common Options](#spline-common-options).

Bézier U
:   Makes the NURBS curve act like a Bézier curve.
    The NURBS control points act like *Free* handles of Bézier curve.

Endpoint U
:   Makes the curve contact the end control points.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   Default NURBS curve. | ../../../_images/modeling_curves_properties_active-spline_nurbs-endpoint.png   A NURBS curve with Endpoint enabled. |

Order U
:   The order of the NURBS curve determines the area of influence of the control points over the curve.
    Higher order values means that a single control point has a greater
    influence over a greater relative proportion of the curve.
    The valid range of *Order* values is 2-6 depending on the number of control points present in the curve.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   NURBS curves with orders of 4. | ../../../_images/modeling_curves_properties_active-spline_nurbs-order.png   NURBS curves with orders of 2. |

Resolution U
:   See [Common Options](#spline-common-options).

Smooth
:   See [Common Options](#spline-common-options).
user: Describe Insert Blank Keyframe (Active Layer) from the Blender manual or Python API, including usage steps and snippets.

assistant: Add a new blank keyframe to the active layer at the current frame.
If there is already a keyframe at the current frame,
a new blank keyframe will be added on the next frame.

All Layers
:   When enabled, Blank keyframe will be created on all layers, not only the active one.

Duration
:   The number of blank frames to insert.
user: Show practical ways to work with Sculpting Brushes in a Blender add-on or script – include code.

assistant: # Sculpting Brushes

Brushes for Grease Pencil *Sculpt* mode bundled in the *Essentials* library.
See [Brush](tool_settings/brush.html) for more information.

[image reference removed]

Smooth Stroke
:   Eliminates irregularities in the area of the drawing
    within the brush’s influence by smoothing the positions of the points.

Thickness Stroke
:   Increase or decrease the points thickness in the area of the drawing
    within the brush’s influence.

Strength Stroke
:   Increase or decrease the points transparency (alpha) in the area of the drawing
    within the brush’s influence.

Randomize Stroke
:   Add noise to the strokes in the area of the drawing
    within the brush’s influence by moving points location in a random way.

Grab Stroke
:   Used to drag a group of points around. Unlike the other brushes,
    Grab does not modify different points as the brush is dragged across the model.
    Instead, Grab selects a group of points on mouse-down, and pulls them to follow the mouse.
    The effect is similar to moving a group of points in Edit Mode with Proportional Editing enabled.

Pull Stroke
:   Moves points in the direction of the brush stroke.

Twist Stroke
:   Twist the points in counter-clockwise (CCW) or Clockwise (CW) rotation.

Pinch Stroke
:   Pulls points towards the center of the brush.
    The inverse setting is Inflate, in which points are pushed away from the center of the brush.

Clone Stroke
:   Adds copies of the strokes in the clipboard in the center of the brush.
    You have to copy the selected strokes you want into the clipboard with `Ctrl`-`C` before using the tool.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Matrix
:   The inverted matrix.

Invertible
:   Returns whether the matrix could be inverted.
    This can be false when a transformation matrix has a scale of zero, for example.
    See [Invertible matrix](https://en.wikipedia.org/wiki/Invertible_matrix) for more information.
user: Give a detailed overview of Set Hair Curve Profile: syntax, arguments, return values, common patterns.

assistant: # Set Hair Curve Profile

The *Set Hair Curve Profile* node defines the radius of hair curves along their length
according to a customizable profile shape.
It allows artists to control the thickness variation from root to tip, producing
natural tapering or stylized width adjustments.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Curve
:   Standard geometry input.

Cuts
:   The number of control points to create on the segment following each point.
    When the input is a field, the number of cuts for a segment is determined by
    the value of the field when evaluated at the previous point.
user: Explain SequencerCacheOverlay(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # SequencerCacheOverlay(bpy_struct)

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

*class* bpy.types.SequencerCacheOverlay(*bpy_struct*)
:   show_cache
    :   Visualize cached images on the timeline

        Type:
        :   boolean, default False

    show_cache_final_out
    :   Visualize cached complete frames

        Type:
        :   boolean, default False

    show_cache_raw
    :   Visualize cached raw images

        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: What is POINTCLOUD_UL_attributes(UIList) and how is it used in Blender Python scripting?

assistant: # POINTCLOUD_UL_attributes(UIList)

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

*class* bpy.types.POINTCLOUD_UL_attributes(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *attribute*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    filter_items(*_context*, *data*, *property*)

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

assistant: # GeometryNodeEdgePathsToSelection(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.GeometryNodeEdgePathsToSelection(*GeometryNode*)
:   Output a selection of edges by following paths across mesh edges

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

assistant: The *Sidebar* (on the right side of the editor area)
contains [Panels](tabs_panels.xhtml#ui-panels)
with settings of objects within the editor and the editor itself.
`N` toggles the visibility of the Sidebar.
user: What is Interior and how is it used in Blender Python scripting?

assistant: # Interior

By default, the edges of a soft-body mesh act like springs. This means that,
like a mechanical spring, they can stretch under tension and squeeze under pressure.
Their initial length is also their “ideal” or “rest” length, which they try to return to.

Having edges act like springs is what holds the mesh together. If you were to disable this
behavior (as well as the [Goal](../settings/goal.xhtml)), each vertex would be free
to go anywhere independently of the others, which would stretch the mesh until it’s
no longer recognizable.

Having springs along edges alone typically isn’t enough, however:
vertices in quads are still free to move towards their diagonal opposite,
potentially collapsing the quad into a line.

You could solve this by creating diagonal edges everywhere, but fortunately,
you don’t have to: simply enable the *Stiffness* option to have Blender create
diagonal springs internally. This way, you don’t have to change your mesh.

|  |  |
| --- | --- |
| ../../../_images/physics_soft-body_forces_interior_theory-1.svg   Base springs along edges. | ../../../_images/physics_soft-body_forces_interior_theory-2.svg   Additional springs when Stiffness is enabled. |

Another method of preventing mesh collapse is applying *Bending Stiffness*,
which adds rotational resistance: making edges try to keep their relative angles.

Both of these methods are described in more detail below. You can configure them,
as well as other settings, in the [Soft Body Edges panel](../settings/edges.xhtml).
user: Show practical ways to work with Rigidbody Object Shape Items in a Blender add-on or script – include code.

assistant: # Rigidbody Object Shape Items

BOX:
:   Box.

    Box-like shapes (i.e. cubes), including planes (i.e. ground planes).

SPHERE:
:   Sphere.

CAPSULE:
:   Capsule.

CYLINDER:
:   Cylinder.

CONE:
:   Cone.

CONVEX_HULL:
:   Convex Hull.

    A mesh-like surface encompassing (i.e. shrinkwrap over) all vertices (best results with fewer vertices).

MESH:
:   Mesh.

    Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls.

COMPOUND:
:   Compound Parent.

    Combines all of its direct rigid body children into one rigid object.
user: Give a detailed overview of Header: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The header of the Properties editor.

Display Filter `Ctrl`-`F`
:   Use this to search for properties by name. Matching properties remain visible; others are grayed out.
    The editor also highlights the first match and switches to the relevant tab automatically.

    Start a search with `Ctrl`-`F`, and clear it with `Alt`-`F`.

Data Context Path
:   Displays the name and icon of the current data-block (e.g. Object, Material, Scene), along with its hierarchical
    path within the data structure.
    Example: *Cube* (Object) –> *Mesh* –> *Material*

Toggle Pin ID
:   Click the pin icon to lock the editor to the current data-block, preventing it from changing when the selection
    updates. Click again to unlock and return to context-based display.

### Options

These options are accessible from the Options popover in the top-right corner of the editor.

Sync with Outliner
:   Controls whether clicking icons in the [Outliner](outliner/introduction.xhtml) changes the active tab.

    Always:
    :   Always follow the clicked Outliner icon.

    Never:
    :   Ignore Outliner interaction.

    Auto:
    :   Only follow when the Properties editor shares a border with the Outliner.

Visible Tabs
:   Allows hiding specific tabs in the Properties editor.

    This is especially useful for tailoring the editor to specific workflows. For example:
    - In the *Video Editing* workspace, you may hide object and shading tabs to reduce clutter.
    - In the *Modeling* workspace, you may hide strip-related tabs that are not relevant.

    Hidden tabs can be restored at any time using this filter list.
user: Give a detailed overview of F-Curves: syntax, arguments, return values, common patterns.

assistant: These settings control how [F-Curves](../graph_editor/fcurves/index.xhtml)
look and their default behavior.

Unselected Opacity
:   Controls the opacity of unselected [F-Curves](../graph_editor/fcurves/index.xhtml) against
    the background of the Graph Editor.

Default Smoothing Mode
:   Controls the behavior of [automatic curve handles](../graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-handles)
    for newly created F-Curves.

Default Interpolation
:   Controls the default [Interpolation](../graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-interpolation)
    for newly created keyframes.

Default Handles
:   Controls the default [Handle](../graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-handles) for newly created F-Curves.

XYZ to RGB
:   Color for X, Y, or Z animation curves (location, scale or rotation)
    is the same as the color for the X, Y, and Z axis.

Channel Group Colors
:   Display groups and channels with colors matching their corresponding groups.

Only Show Selected F-Curve Keyframes
:   Only shows the keyframes markers on the selected curves.

F-Curve High Quality Drawing
:   Display F-Curves using [Anti-Aliasing](../../glossary/index.xhtml#term-Anti-Aliasing) and other effects (disable for a better performance).
user: Explain Dyntopo in complete detail according to the official Blender documentation.

assistant: # Dyntopo

Dynamic Topology (aka Dyntopo) can be toggled with the checkbox.
With dynamic topology active, most brushes will subdivide the mesh during the stroke.

For a general explanation of dynamic topology, visit
the [Introduction](../introduction/adaptive.html).

Detail Size/Percentage, Resolution `R`
:   Each Detail Type’s detail is set here. Depending on the Detail Type being used
    this property will rather show as a pixel count (px), or percentage.

    `R` allows you to interactively set the detail, with a preview of the detail’s density in the 3D Viewport.

    Sample Detail Size
    :   When using *Constant Detail*, it is possible to sample the detail value of a certain mesh area
        by clicking the pipette icon next to the detail setting and then clicking on the area.

Refine Method
:   Setting the option will determine which of the methods will be used when altering the topology.

    Subdivide Edges:
    :   Just like the Subdivide tool, this method will only subdivide topology
        to match the detail given.

    Collapse Edges:
    :   When topology is too dense, and is smaller than the detail given, edges will
        be collapsed to fit the detail size appropriately.

    Subdivide Collapse:
    :   This method combines the two methods, subdividing edges smaller than
        the detail size, and collapsing topology.

Detailing
:   Dyntopo uses the following different detail methods to create dynamic detail on an object.

    Relative Detail:
    :   This method uses a detail size based on the number of pixels, and in turn
        will create topology in that size. Zoom out big details, zoom in small fine details.

    Constant Detail:
    :   To keep detail uniform across the entire object, Constant Detail can be used.
        The detail is a divisor of a Blender unit - higher values mean finer details.

    Brush Detail:
    :   Giving more control over the topology, with this method you can create topology
        based on the brush size. You can increase and lower topology by resizing the brush itself.
        The detail size is based the size of the brush itself,
        where full detail will create topology the size of the brush radius itself.

    Manual Detail:
    :   Similar to constant detail, this value sets a percentage value uniform across the object, but only
        applies detailing changes when using Flood Fill.

Detail Flood Fill `Ctrl`-`R`
:   When using *Constant* or *Manual* *Detailing*, this option is made available,
    allowing you to fill the entire object with a uniform detail, based on the resolution.
user: What is Linesets(bpy_struct) and how is it used in Blender Python scripting?

assistant: # Linesets(bpy_struct)

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

*class* bpy.types.Linesets(*bpy_struct*)
:   Line sets for associating lines and style parameters

    active
    :   Active line set being displayed

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

    active_index
    :   Index of active line set slot

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

    new(*name*)
    :   Add a line set to scene render layer Freestyle settings

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the line set (not unique)

        Returns:
        :   Newly created line set

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

    remove(*lineset*)
    :   Remove a line set from scene render layer Freestyle settings

        Parameters:
        :   **lineset** ([`FreestyleLineSet`](bpy.types.FreestyleLineSet.html#bpy.types.FreestyleLineSet "bpy.types.FreestyleLineSet"), (never None)) – Line set to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Defines a bendy and stretchy b-bones spine.

Pivot Position (integer)
:   Defines the pivot position for torso and hips.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.

FK Controls
:   Specifies whether to generate an FK control chain.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.
user: What is CompositorNodeTonemap(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeTonemap(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.CompositorNodeTonemap(*CompositorNode*)
:   Map one set of colors to another in order to approximate the appearance of high dynamic range

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Duplicate in complete detail according to the official Blender documentation.

assistant: # Duplicate

This will create a visually-identical copy of the selected object(s).
The copy is created at the same position as the original object and
you are automatically placed in move mode. See the examples below.

This copy is a new object, which shares data-blocks with the original object
(by default, all the materials, textures, and F-Curves), but which has copied others,
like the mesh, for example. That is why this form of duplication is sometimes called “shallow link”,
because not all data-blocks are shared; some of them are “hard copied”!
user: What is Crashes and how is it used in Blender Python scripting?

assistant: # Crashes

The most common causes of Blender crashes:

- Running out of memory.
- Issues with graphics hardware or drivers.
- Bugs in Blender.

Firstly, you may be able to recover your work with [Auto Save](recover.html#troubleshooting-file-recovery-auto-save).

To prevent the problem from happening again, you can check that the graphics drivers are up to date
([Troubleshooting Graphics Hardware](gpu/index.html#troubleshooting-gpu-index)), upgrade your machine’s hardware (the RAM or graphics card), and disable some
options that are more memory intensive:

- Reduce undo steps Preferences ‣ System ‣ Memory & Limits ‣ Undo Steps.
- Using multisample anti-aliasing also increases the memory usage and makes the display slower.
- On Linux, the Window Manager (KDE and Gnome for example) may be using hardware accelerated effects (e.g. window
  shadows and transparency) that are using up the memory that Blender needs. Try disabling the desktop effects or
  switch to a lightweight Window Manager.

To check memory usage by Blender:

- On Windows, use Task Manager and sort by Memory.
- On macOS, use Activity Monitor.app and open Memory tab. Alternatively, run `top -o MEM`.
- On Linux, run `top -o %MEM`.

In more extreme cases, you may want to consider reinstalling your operating system. Windows especially tends to build
up latent issues due to successive updates and program leftovers.
user: Give a detailed overview of Geometry Randomization: syntax, arguments, return values, common patterns.

assistant: Many nodes don’t guarantee the order of elements in which they output things. For example, the order of edges coming
out of the **Triangulate** node is deterministic but not well defined. The order may change between Blender versions.
Therefor, if node setups depend on a specific order, they may break when the Blender implementation changes. Changing
the order can often be necessary in order to fix bugs or improve performance.

“Geometry randomization” can be temporarily enabled to see if a blend-file depends on the indices in unstable ways.
When enabled, various internal algorithms shuffle the result geometry elements so that any dependence on it would not
work anymore. When building setups that are supposed to last a long time, it is recommended to check if they still
work with randomization enabled.

To enable it, first enable **Developer Extras** in the [preferences](../../editors/preferences/interface.xhtml).
Then [search](../../interface/operators.xhtml#bpy-ops-wm-search-operator) for **Set Geometry Randomization**.
The popup allows enabling and disabling the randomization.
user: Give a detailed overview of MeshLoopTriangles(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MeshLoopTriangles(bpy_struct)

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

*class* bpy.types.MeshLoopTriangles(*bpy_struct*)
:   Tessellation of mesh polygons into triangles

    *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 Calligraphy and how is it used in Blender Python scripting?

assistant: # Calligraphy

The *Calligraphy* modifier mimics some broad and flat pens for calligraphy.
It generates different thickness based on the orientation of the stroke.

Orientation
:   The angle (orientation) of the virtual drawing tool, from the vertical axis of the picture.
    For example, an angle of 0.0 mimics a pen aligned with the vertical axis.
    Hence, the thickest strokes will be the vertical ones i.e. stroke’s direction is aligned with the angle, and
    the thinnest will be the horizontal ones i.e. stroke’s direction is perpendicular to the angle.

[image reference removed]

Calligraphy modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_Calligraphy.zip)).