PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Area(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Area(bpy_struct)

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

*class* bpy.types.Area(*bpy_struct*)
:   Area in a subdivided screen, containing an editor

    height
    :   Area height

        Type:
        :   int in [0, 32767], default 0, (readonly)

    regions
    :   Regions this area is subdivided in

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

    show_menus
    :   Show menus in the header

        Type:
        :   boolean, default False

    spaces
    :   Spaces contained in this area, the first being the active space (NOTE: Useful for example to restore a previously used 3D view space in a certain area to get the old view orientation)

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

    type
    :   Current editor type for this area

        Type:
        :   enum in [Space Type Items](bpy_types_enum_items/space_type_items.html#rna-enum-space-type-items), default `'VIEW_3D'`

    ui_type
    :   Current editor type for this area

        Type:
        :   enum in []

    width
    :   Area width

        Type:
        :   int in [0, 32767], default 0, (readonly)

    x
    :   The window relative vertical location of the area

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    y
    :   The window relative horizontal location of the area

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    tag_redraw()
    :   tag_redraw

    header_text_set(*text*)
    :   Set the header status text

        Parameters:
        :   **text** (*string*) – Text, New string for the header, None clears the text

    *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.Area.type "bpy.types.Area.type")
user: How do I use Chroma Key Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Chroma Key Node

[image reference removed]

The *Chroma Key* node determines if a pixel is a foreground or background
(and thereby should be transparent) based on its chroma values.

Use this, for example, to composite images that have been shot in front of a green or blue screen.
user: How do I use Attributes in Blender? Include parameters, examples, warnings and best practices.

assistant: An attribute is data stored per mesh element. Every attribute has a data type, domain and name.
This panel only lists custom attributes which excludes all the built-in attributes like `position` and
other attributes like vertex groups.

See [Attributes Reference](../../geometry_nodes/attributes_reference.xhtml) for more information.
user: How do I use Arranging in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Scrolling

A region can be scrolled vertically and/or horizontally by dragging it with the `MMB`.
If the region has no zoom level, it can also be scrolled by using the `Wheel`
while the mouse hovers over it.

Some regions, in particular animation timelines, have scrollbars with added control points
to adjust the vertical or horizontal range of the region.
These special scrollbars will have added widgets at the ends, as shown in the following image:

[image reference removed]

Scrollbars with zoom widgets.

This can be used to stretch or compress the range to show more or less detail within the available screen space.
Simply drag one of the dots to either increase or decrease the displayed range.
You can also quickly adjust both the horizontal and vertical range by dragging in the editor with `Ctrl`-`MMB`.

### Changing the Size and Hiding Regions

Resizing regions works by dragging their border, the same way as
[Areas](areas.xhtml).

To hide a region, resize it down to nothing.
A hidden region leaves a little arrow sign.
`LMB` on this icon to make the region reappear.

Hiding and showing the Sidebar.

|  |  |
| --- | --- |
| ../../_images/interface_window-system_regions_sidebar-hide.png | ../../_images/interface_window-system_regions_sidebar-show.png |

### Scaling

The scale of certain regions (such as the Toolbar) can be changed by dragging inside them
with `Ctrl`-`MMB`, or using `NumpadPlus` and `NumpadMinus` while hovering the
mouse cursor over them. Press `Home` to reset the scale to the default.
user: Give a detailed overview of Newtonian: syntax, arguments, return values, common patterns.

assistant: # Newtonian

The particles will move according to classical (Newtonian) mechanics.
Particles start their life with the specified initial velocities and angular velocities,
and move according to external forces.
The response to environment and to forces is computed differently,
according to the given integrator chosen by the animator.

[image reference removed]

Newtonian Physics settings.
user: Show practical ways to work with GeometryNodeCurvesToGreasePencil(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeCurvesToGreasePencil(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.GeometryNodeCurvesToGreasePencil(*GeometryNode*)
:   Convert the curves in each top-level instance into Grease Pencil layer

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain GeometryNodeCameraInfo(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeCameraInfo(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.GeometryNodeCameraInfo(*GeometryNode*)
:   Retrieve information from a camera object

    *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 bpy_extras submodule (bpy_extras.asset_utils) in Blender? Include parameters, examples, warnings and best practices.

assistant: # bpy_extras submodule (bpy_extras.asset_utils)

Helpers for asset management tasks.

*class* bpy_extras.asset_utils.AssetBrowserPanel

*class* bpy_extras.asset_utils.AssetMetaDataPanel

*class* bpy_extras.asset_utils.SpaceAssetInfo
user: Describe GroupNodeViewerPathElem(ViewerPathElem) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GroupNodeViewerPathElem(ViewerPathElem)

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

*class* bpy.types.GroupNodeViewerPathElem(*ViewerPathElem*)
:   node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Weight Paint Tools

Brush
:   Tool to use for any of the weight paint [brushes](brushes.xhtml).

Gradient
:   Applies a linear/radial weight gradient;
    this is useful at times when painting gradual changes in weight becomes difficult.
    Blends the weights of selected vertices with unselected vertices.

    [image reference removed]

    Example of the Gradient tool being used with selected vertices.

    Weight
    :   The gradient starts at the current selected weight value, blending out to nothing.

    Strength
    :   Lower values can be used so the gradient mixes in with the existing weights (just like with the brush).

    Type
    :   The shape of the gradient.

        Linear:
        :   Create gradient that forms a straight line.

        Radial:
        :   Create gradient that forms a circle.

Sample
:   Weights
    :   Sets the brush *Weight* as the weight selected under the cursor.
        The sampled weight is displayed in the tool settings.

    Vertex Group
    :   Displays a list of possible vertex groups to select that are under the cursor.

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

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

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

    [Annotate Eraser](../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

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

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

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

Height
:   Height of the spiral.

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

assistant: Set as Background
:   See [Set as Background](../editing/clip.html#bpy-ops-clip-set-viewport-background).

Setup Tracking Scene
:   See [Setup Tracking Scene](../editing/clip.html#bpy-ops-clip-setup-tracking-scene).
user: Give a detailed overview of Limitations/Considerations: syntax, arguments, return values, common patterns.

assistant: The positioning of the instanced geometry relative to the face is dependent upon the position
of the child objects relative to the instancer’s origin. This can lead to some visual artifacts
in the 3D Viewport as the geometry of the original objects overlaps or intersects with
the instanced geometry.
One workaround is to move the origin of the instancer mesh off of the plane of the faces.

If the geometry of the children is not symmetrical then the orientation of the face
(as determined by the order of its vertices) could matter. As of 2.70 Blender does not have
tools which allow you to adjust the ordering of the vertices on a face.

However, there is a workflow that lets you control for this. Make a single square and
enable the *Instancing Faces* so you can see the instanced geometry in the 3D Viewport.
If the orientation is not what you want, rotate the face until it is how you want.
Typically you want to do the rotation in Edit Mode, not Object Mode,
but this is not a hard rule.

Once you have the orientation correct,
Duplicate the face and move the duplicate where you want it.
Repeat this process until you have enough faces.
Since it is common for these faces to butt up against one another,
your geometry will have lots of duplicate vertices.
Use the *Merge by Distance* button in the Tools panel.

Demo Video

[A short video illustrating this workflow](https://www.youtube.com/watch?v=diI8xJ9oo_8)
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`BlendData.paint_curves`](bpy.types.BlendData.html#bpy.types.BlendData.paint_curves "bpy.types.BlendData.paint_curves") | - [`Brush.paint_curve`](bpy.types.Brush.html#bpy.types.Brush.paint_curve "bpy.types.Brush.paint_curve") |
user: What is Set Handle Type and how is it used in Blender Python scripting?

assistant: Handle types are a property of [Bézier curves](../../curves/structure.html#curve-bezier) and
can be used to alter features of the curve.
For example, switching to *Vector handles* can be used to create curves with sharp corners.
Read the [Bézier curves](../../curves/structure.html#curve-bezier-handle-type) page for more details.

Type
:   The handle type to switch to.

    Auto:
    :   This handle has a completely automatic length and direction
        which is set by Blender to ensure the smoothest result.
        These handles convert to *Align* handles when moved.

    Vector:
    :   Both parts of a handle always point to the previous handle or the next handle which allows
        you to create curves or sections thereof made of straight lines or with sharp corners.
        Vector handles convert to *Free* handles when moved.

    Align:
    :   These handles always lie in a straight line,
        and give a continuous curve without sharp angles.

    Free:
    :   The handles are independent of each other.

    Toggle Free/Align:
    :   Replaces Free handles with Align, and all Align with Free handles.
user: Show practical ways to work with GPU Rendering in a Blender add-on or script – include code.

assistant: # GPU Rendering

GPU rendering makes it possible to use your
graphics card for rendering, instead of the CPU. This can speed up rendering
because modern GPUs are designed to do quite a lot of number crunching.
On the other hand, they also have some limitations in rendering complex scenes, due to more limited memory,
and issues with interactivity when using the same graphics card for display and rendering.

To enable GPU rendering:

1. Select either *CUDA*, *OptiX*, *HIP*, *oneAPI*, or *Metal*
   in the [Cycles Render Devices](../../editors/preferences/system.xhtml#editors-preferences-cycles) user preference.
2. Enable the available devices for the chosen backend.
3. Configure each scene to use the *GPU Compute* [Device](render_settings/index.xhtml#bpy-types-cyclesrendersettings-device).
user: Provide the full official documentation entry for Animation, preserving all code examples.

assistant: # Animation

The *Animation* section lets you manage settings related to [Animation](../../animation/index.html).
This includes how editors look and also some different tools properties.

[image reference removed]

Blender Preferences Animation section.
user: What is AttributeGroupGreasePencilDrawing(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AttributeGroupGreasePencilDrawing(bpy_struct)

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

*class* bpy.types.AttributeGroupGreasePencilDrawing(*bpy_struct*)
:   Group of geometry attributes

    active
    :   Active attribute

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

    active_index
    :   Active attribute index or -1 when none are active

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

    new(*name*, *type*, *domain*)
    :   Add attribute to geometry

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name, Name of geometry attribute
            - **type** (enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items)) – Type, Attribute type
            - **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   New geometry attribute

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

    remove(*attribute*)
    :   Remove attribute from geometry

        Parameters:
        :   **attribute** ([`Attribute`](bpy.types.Attribute.html#bpy.types.Attribute "bpy.types.Attribute"), (never None)) – Geometry Attribute

    domain_size(*domain*)
    :   Get the size of a given domain

        Parameters:
        :   **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   Size, Size of the domain

        Return type:
        :   int in [0, inf]

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

assistant: # TextureNodeTexWood(TextureNode)

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

*class* bpy.types.TextureNodeTexWood(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: A more formal definition of a meta object can be given as a *directing structure* which can
be seen as the source of a static field. The field can be either positive or negative and
hence the field generated by neighboring directing structures can attract or repel.

The implicit surface is defined as the surface where the 3D field generated by
all the directing structures assume a given value. For example a meta ball,
whose directing structure is a point, generates
an isotropic (i.e. identical in all directions) field around it and
the surfaces at constant field value are spheres centered at the directing point.

*Meta* objects are nothing more than mathematical formula that perform logical operations on one another
(AND, OR), and that can be added and subtracted from each other.
This method is also called *Constructive Solid Geometry* (CSG).
Because of its mathematical nature, CSG uses little memory, but requires lots of processing power to compute.
user: Give a detailed overview of Align to Transform Orientation: syntax, arguments, return values, common patterns.

assistant: # Align to Transform Orientation

Aligns (rotates) the selected objects so that their local orientation matches the active transform orientation
in the Transform orientation panel or the *Orientation* selection
in the Transform [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panels.
user: How do I use Creating Extensions in Blender? Include parameters, examples, warnings and best practices.

assistant: # Creating Extensions

Extensions are **add-ons** or **themes** used to extend the core functionality of Blender.
They are shared in online platforms, and can be installed and updated from within Blender.

The official extensions platform for the Blender project is [extensions.blender.org](https://extensions.blender.org).
Other third party sites can also be supported, as long as they follow the Extensions Platform specification.
user: Provide the full official documentation entry for Crash Log, preserving all code examples.

assistant: When Blender crashes, it writes out a text file which contains information that may help identify the cause of the
crash. Usually, this file is written in the [Temporary Directory](../advanced/blender_directory_layout.xhtml#temp-dir) directory.

This file contains a log of tools used up until the crash as well as some other debug information. When reporting bugs
about crashes it can be helpful to attach this file to your reports, especially when others are unable to reproduce
the crash.

### Windows

On a crash, a file is written based on the name of the currently loaded blend-file, so `test.blend` will create a
file called `test.crash.txt`.

Batch scripts are provided in Blender installation directory which may be run to obtain the Blender debug log and
system info text files:

- `blender_debug_log.cmd` is used in most cases.
- `blender_debug_gpu.cmd` and `blender_debug_gpu_workaround.cmd` log GPU-related errors.
- `blender_factory_startup.cmd` starts Blender with default settings which is recommended for debugging.

If the crash happens in Blender module, stack trace is also written to a file named `blender.crash.txt`.
The path to that file can be found at the end of `blender_debug_out.txt` file.

### macOS

After a crash, the macOS Crash Reporter shows a window with backtrace after some time, or when Blender is opened
again. Copy the text in the crash report and save it in a text file. That file should be attached to the bug report
while following other bug reporting guidelines.

Some `.crash` files can also be found in `~/Library/Logs/DiagnosticReports/` with the name of format:
`Blender_YYYY-MM-DD-HHMMSS_MACNAME.crash`. If a report is present corresponding to the time of crash, that file can
also provide hints about cause of the crash. Alternatively, Console.app can be used to navigate all “User Reports”
(see sidebar in the app).

### Linux

After a crash, a file named `blender.crash.txt` is written to the `/tmp` directory.
user: How do I use Transform Panel in Blender? Include parameters, examples, warnings and best practices.

assistant: # Transform Panel

When nothing is selected, the panel is empty.
When more than one vertex is selected, the median values are edited
and “Median” is added in front of the labels.

Control Point, Vertex
:   The first controls (X, Y, Z) show the coordinates of the selected point or handle (vertex).
    In case of a NURBS curve, there is a fourth component available (W),
    which defines the [weight](../structure.xhtml#curves-structure-nurbs-weight)
    of the selected control point or the median weight.

Space
:   The Space radio buttons let you choose if those coordinates are relative
    to the object origin (local) or the global origin (global).

    Global, Local

Weight
:   Controls the “goal weight” of selected control points,
    which is used when a curve has [Soft Body](../../../physics/soft_body/index.xhtml) physics,
    forcing the curve to “stick” to their original positions, based on the weight.

Radius
:   Controls the width of the extrusion/bevel along the “spinal” curve.
    The radius will be interpolated from point to point (you can check it with the normals).

Tilt
:   Controls how the normals (visualized as arrows)
    twist around each control point – so it is only relevant with 3D curves!
    The tilt will be interpolated from point to point (you can check it with the normals).
user: Provide the full official documentation entry for Socket Syncing, preserving all code examples.

assistant: Bundles use socket names to match their inputs and outputs.
If two bundle nodes are connected but have mismatched signatures,
Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never updated automatically to avoid overwriting data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Start/End Frame
:   Start frame and End frame of the range of time specifying the values
    the output should last. This range becomes the X axis of the graph.
    The time input could be reversed by specifying a start frame greater than the end frame.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Bake Mode
:   The *Bake* node can calculate the geometry of a single frame or an animation.

    Animation:
    :   Bakes the geometry data for multiple frames.
        By default the scene frame range is used, however, a *Custom Range* can also be defined.

    Still:
    :   Bakes the geometry data of the current frame.

Bake
:   Preforms all necessary geometry calculations and saves the data on disk or packed into the .blend file.

    Pack/Unpack
    :   Packs or unpacks already baked data. When unpacking, there are different options to control where the data will
        be stored. The options are the same as for the [Unpack Resources](../../../../files/blend/packed_data.xhtml#bpy-ops-file-unpack-all) operator.

    Delete Geometry Node Bake
    :   Deletes the bake data.

Bake Target
:   Specifies where the baked data should be stored.

    Inherit from Modifier:
    :   The setting is copied from the modifier that contains the bake node. This is the default.

    Packed:
    :   The baked data is packed into the .blend file. So no separate file is necessary.

    Disk:
    :   The baked data is stored in a separate directory on disk.

Custom Path
:   Specify a path where the baked data should be stored manually.

    Bake Path
    :   Location on disk where the baked data is stored.
        Note, this path is also used for [simulation zones](../../simulation/simulation_zone.xhtml).

Custom Range Animation
:   Override the simulation frame range from the scene.

Start, End
:   The start and end frame numbers for the custom range.
user: What is Specular BSDF and how is it used in Blender Python scripting?

assistant: # Specular BSDF

[image reference removed]

EEVEE Only

The *Specular* BSDF
combines multiple layers into a single easy to use node.

It is similar to the [Principled BSDF](principled.html) node
but uses the *specular* workflow instead of the metallic.
It has far fewer parameters and supports less features. Both might be merged into one node in the future.

The specular workflow functions by specifying the facing (along normal) reflection color.
The result may not be physically plausible because there is no energy conservation.
user: Show practical ways to work with Forces in a Blender add-on or script – include code.

assistant: Brownian
:   Specify the amount of Brownian motion.
    Brownian motion adds random motion to the particles based on a Brownian noise field.
    This is nice to simulate small, random wind forces.

Drag
:   A force that reduces particle velocity in relation to its speed and size
    (useful in order to simulate air drag or water drag).

Damp
:   Reduces particle velocity (deceleration, friction, dampening).
user: How do I use ConstraintTargetBone(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ConstraintTargetBone(bpy_struct)

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

*class* bpy.types.ConstraintTargetBone(*bpy_struct*)
:   Target bone for multi-target constraints

    subtarget
    :   Target armature bone

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

    target
    :   Target armature

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

    weight
    :   Blending weight of this bone

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain MaskLayers(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # MaskLayers(bpy_struct)

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

*class* bpy.types.MaskLayers(*bpy_struct*)
:   Collection of layers used by mask

    active
    :   Active layer in this mask

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

    new(*\**, *name=''*)
    :   Add layer to this mask

        Parameters:
        :   **name** (*string**,* *(**optional**,* *never None**)*) – Name, Name of new layer

        Returns:
        :   New mask layer

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

    remove(*layer*)
    :   Remove layer from this mask

        Parameters:
        :   **layer** ([`MaskLayer`](bpy.types.MaskLayer.html#bpy.types.MaskLayer "bpy.types.MaskLayer"), (never None)) – Shape to be removed

    clear()
    :   Remove all mask layers

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

assistant: This panel contains operators and their settings which are needed to clean up bad tracks:
tracks which are not tracked long enough or which failed to reconstruct accurately.

Frames
:   Tracks or tracked segments shorter than this number of frames will be removed.

Error
:   Tracks which has reprojection error higher than this value will be removed.

Type
:   Several actions can be performed for bad tracks:

    Select:
    :   They can simply be selected.

    Delete Track:
    :   The whole track can be deleted.

    Delete Segments:
    :   Bad segments of tracked sequence can be removed.

Clean Tracks
:   See [Clean Tracks](../editing/track.html#bpy-ops-clip-clean-tracks).

Filter Tracks
:   See [Filter Tracks](../editing/track.html#bpy-ops-clip-filter-tracks).
user: What is Annotations and how is it used in Blender Python scripting?

assistant: # Annotations

The annotation tool is available in multiple editors.
It can be used to add notes to e.g. 3D objects or node setups.
The arrow in the screenshot below is an annotation.

[image reference removed]

Annotations tool in a node editor.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_deform_lattice_panel.png)

The Lattice modifier.

Object
:   The [Lattice](../../../animation/lattice.html) object with which to deform the base object.

Vertex Group
:   An optional vertex group name which lets you limit the modifier’s effect to a part of the base mesh.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

Strength
:   A factor to control blending between original and deformed vertex positions.
user: Provide the full official documentation entry for Toolbar, preserving all code examples.

assistant: # Toolbar

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

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

    [Select Circle](../../../../interface/selecting.xhtml#tool-select-circle)
    :   Select UVs by painting on it.

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

Cursor
:   Change the location of the 2D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

Transform
:   Tool to adjust the UVs translation, rotation and scale.

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

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

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

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

[Rip](rip.xhtml)
:   The Rip tool separates UV faces from each other.

[Grab](grab.xhtml)
:   The Grab tool moves UVs around using a brush.

[Relax](relax.xhtml)
:   The Relax tool makes UVs more evenly distributed using a brush.

[Pinch](pinch.xhtml)
:   The Pinch tool moves UVs toward the brush’s center.
user: Provide the full official documentation entry for Texture Operators, preserving all code examples.

assistant: # Texture Operators

bpy.ops.texture.new()
:   Add a new texture

bpy.ops.texture.slot_copy()
:   Copy the material texture settings and nodes

bpy.ops.texture.slot_move(*\**, *type='UP'*)
:   Move texture slots up and down

    Parameters:
    :   **type** (enum in [`'UP'`, `'DOWN'`], (optional)) – Type

bpy.ops.texture.slot_paste()
:   Copy the texture settings and nodes
user: Describe EEVEE only Nodes from the Blender manual or Python API, including usage steps and snippets.

assistant: These nodes are only available if EEVEE is the active render engine. These nodes will not work in Cycles.

### Shader to RGB

EEVEE supports the conversion of BSDF outputs into color inputs to make a wide variety of custom shading.
This is supported using the [Shader to RGB](../../shader_nodes/color/shader_to_rgb.xhtml) node.
This node evaluates the lighting of the BSDFs connected to it just like a *Blended* material and inherits
its limitation.

### Specular BSDF

This [node](../../shader_nodes/shader/specular_bsdf.xhtml) implements the specular workflow
found in other render engines.
user: Show practical ways to work with Bpy.Types.Wavemodifier in a Blender add-on or script – include code.

assistant: WaveModifier.texture WaveModifier.texture_coords WaveModifier.texture_coords_bone WaveModifier.texture_coords_object WaveModifier.time_offset WaveModifier.use_cyclic WaveModifier.use_normal WaveModifier.use_normal_x WaveModifier.use_normal_y WaveModifier.use_normal_z WaveModifier.use_x WaveModifier.use_y WaveModifier.uv_layer WaveModifier.vertex_group WaveModifier.width WaveModifier.bl_rna_get_subclass() WaveModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with GeometryNodeCornersOfVertex(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeCornersOfVertex(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.GeometryNodeCornersOfVertex(*GeometryNode*)
:   Retrieve face corners connected to vertices

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`AssetMetaData.tags`](bpy.types.AssetMetaData.html#bpy.types.AssetMetaData.tags "bpy.types.AssetMetaData.tags") - [`AssetTags.new`](bpy.types.AssetTags.html#bpy.types.AssetTags.new "bpy.types.AssetTags.new") | - [`AssetTags.remove`](bpy.types.AssetTags.html#bpy.types.AssetTags.remove "bpy.types.AssetTags.remove") |
user: How do I use VIEWLAYER_UL_aov(UIList) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VIEWLAYER_UL_aov(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.VIEWLAYER_UL_aov(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*)

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

assistant: # Introduction

Draw Mode is the mode in Grease Pencil that allows you to draw in the 3D Viewport.
This mode is actually the only one in which new strokes can be created.

Already made strokes can not be selected in Draw Mode, for editing strokes you must use
the [Edit Mode](../edit/introduction.xhtml) or
[Sculpt Mode](../sculpting/introduction.xhtml).

[image reference removed]

3D Viewport Mode selector: Draw Mode.

Draw Mode is selected with the *Mode* menu in the 3D Viewport header.
Once Draw Mode is activated, the Toolbar of the 3D Viewport will change to Draw Mode specific panels.
Also a circle with the same color as the active material will appear and
follow the location of the cursor in the 3D Viewport.

To create new strokes you have to select one of the drawing tools in the Toolbar.
The most common one is the [Draw tool](tools.xhtml)
for free-hand drawings but there are many other tools for drawing, filling areas and erasing strokes.
There are also some tools to create primitives shapes like lines, arcs, curves, boxes and circles.

See [Toolbar](tools.xhtml) for more details.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Closure
:   The closure to evaluate.
    This input expects a connection from a [Closure Zone](../../../../interface/controls/nodes/types/utilities/closure/closure.xhtml).
    If no closure is connected, the node operates in *pass-through mode* (see below).

### Interface

The node can define additional inputs manually, which are matched by name to the corresponding inputs of the connected
closure. When the closure is connected, these sockets automatically sync to reflect the closure’s defined interface.
user: Explain Extending Blender in complete detail according to the official Blender documentation.

assistant: ### Add-ons

Add-ons are scripts that enable Blender to gain extra functionality;
they can be enabled from the [Preferences](../../editors/preferences/extensions.xhtml).

Outside of the Blender executable, there are hundreds of add-ons written by many people:

- Officially supported add-ons are bundled with Blender.
- Other add-ons are provided by [Blender Extensions](https://extensions.blender.org/)
  which aren’t part of official releases.
  Many of them work reliably and are very useful but are not yet ensured to be stable for release.

### Scripts

Apart from add-ons, there are several other types of scripts that extend Blender’s functionality:

Modules:
:   Utility libraries for import into other scripts.

Presets:
:   Settings for Blender’s tools and key configurations.

Startup:
:   These files are imported when starting Blender.
    They define most of Blender’s UI, as well as some additional core operators.

Custom Scripts:
:   In contrast to add-ons, they are typically intended for one-time execution via
    the [Text Editor](../../editors/text_editor.xhtml).

### Saving your own Scripts

#### File Location

All scripts are loaded from the `scripts` folder of
the [local, system and user paths](../blender_directory_layout.xhtml#blender-directory-layout).

You can setup an additional search path for scripts in
[File Paths](../../editors/preferences/file_paths.xhtml#prefs-file-paths) Preferences ‣ File Paths.

#### Installation

Add-ons are conveniently installed through Blender in the [Preferences](../../editors/preferences/extensions.xhtml).
Click the Install… button and select the `.zip` file.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Strength
:   Strength of the bump mapping effect, interpolating between no bump mapping and full bump mapping.

Distance
:   Multiplier for the height value to control the overall distance for bump mapping.

Filter Width
:   Filter width in pixels, used to compute the bump mapping direction. For most textures
    the default value of 0.1 enables subpixel filtering for stable results. For stepwise
    textures a larger filter width can be used to get a bevel like effect on edges

Height
:   Scalar value giving the height offset from the surface at the shading point; this is where you plug in textures.

Normal
:   Standard normal input.
user: Show practical ways to work with Separate in a Blender add-on or script – include code.

assistant: Separates curve objects that are made of multiple distinct curves into their own objects.

Note, if there is only one curve in a Curve object,
This operation will create a new Curve object with no control points.