PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Usage and how is it used in Blender Python scripting?

assistant: Application templates are a feature that allows you to define a re-usable configuration
that can be selected to replace the default configuration,
without requiring a separate Blender installation or overwriting your personal settings.

Application templates can be selected from the splash screen or File ‣ New submenu.
When there are no templates found the menu will not be displayed on the splash screen.

New application templates can be installed from the [Blender Menu](../interface/window_system/topbar.xhtml#topbar-blender-menu).
If you would like to keep the current application template active on restarting Blender, save your preferences.

### Motivation

In some cases it’s not enough to write a single script or add-on,
and expect someone to replace their preferences and startup file, install scripts and change their keymap.

The goal of application templates is to support switching to a customized configuration
without disrupting your existing settings and installation.
This means people can build their own *applications* on top of Blender that can be easily distributed.

### Details

An application template may define its own:

Startup File
:   The default file to load with this template.

Preferences
:   Only certain preferences from a template are used:

    - Themes.
    - Add-ons.
    - Keymaps.
    - Viewport lighting.

Splash Screen
:   Templates may provide their own splash screen image.

Python Scripts
:   While templates have access to the same functionality as any other scripts,
    typical operations include:

    - Modifying and replacing parts of the user interface.
    - Defining new menus, keymaps and tools.
    - Defining a custom add-on path for template specific add-ons.

Templates also have their own user configuration, so saving a startup file while using a template
won’t overwrite your default startup file.

### Directory Layout

Templates may be located in one of two locations within the `scripts` directory.

Template locations:
:   `{BLENDER_USER_SCRIPTS}/startup/bl_app_templates_user`

    `{BLENDER_SYSTEM_SCRIPTS}/startup/bl_app_templates_system`

User configuration is stored in a subdirectory:

Without a template:
:   `./config/startup.blend`

    `./config/userpref.blend`

With a template:
:   `./config/{APP_TEMPLATE_ID}/startup.blend`

    `./config/{APP_TEMPLATE_ID}/userpref.blend`

See [Blender’s Directory Layout](blender_directory_layout.xhtml#blender-directory-layout) for details on script and configuration locations.

### Command Line Access

Using the [command-line arguments](command_line/arguments.xhtml#command-line-args) you can setup a launcher
that opens Blender with a specific app template:

```
blender --app-template my_template
```
user: Show practical ways to work with Geometry Data in a Blender add-on or script – include code.

assistant: # Geometry Data

This panel is used to manage any generic data attributes that a mesh could have.

Clear Sculpt Mask Data
:   Deletes the internal `sculpt_mask` attribute.
    This attribute is used by the [Sculpt Masking Feature](../../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.xhtml#face-sets).

Add/Clear Skin Data
:   Used to manage the skin data which is used by the [Skin Modifier](../../modifiers/generate/skin.xhtml).
    This operator can be needed in case a Skin modifier is created but no skin data exist.

Reorder Mesh Spatially
:   The operation sorts the vertex and face indices according to their location in space,
    so nearby geometry elements are also nearby in memory.

    This does not change the visible geometry or topology of the mesh.
    This does however improve performance in areas where spatial coherence is important, such as:

    - Faster BVH (Bounding Volume Hierarchy) building for rendering and viewport performance.
    - Improved memory access patterns during sculpting on high-poly meshes.
    - Potentially smoother interaction in edit and sculpt modes on dense geometry.

Add/Clear Custom Split Normals Data
:   Adds [Custom Split Normals](../structure.xhtml#modeling-meshes-normals-custom) data, if none exists yet.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`StripColorBalanceData.correction_method`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.correction_method "bpy.types.StripColorBalanceData.correction_method") - [`StripColorBalanceData.lift`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.lift "bpy.types.StripColorBalanceData.lift") - [`StripColorBalanceData.gamma`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.gamma "bpy.types.StripColorBalanceData.gamma") - [`StripColorBalanceData.gain`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.gain "bpy.types.StripColorBalanceData.gain") - [`StripColorBalanceData.slope`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.slope "bpy.types.StripColorBalanceData.slope") - [`StripColorBalanceData.offset`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.offset "bpy.types.StripColorBalanceData.offset") | - [`StripColorBalanceData.power`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.power "bpy.types.StripColorBalanceData.power") - [`StripColorBalanceData.invert_lift`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.invert_lift "bpy.types.StripColorBalanceData.invert_lift") - [`StripColorBalanceData.invert_gamma`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.invert_gamma "bpy.types.StripColorBalanceData.invert_gamma") - [`StripColorBalanceData.invert_gain`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.invert_gain "bpy.types.StripColorBalanceData.invert_gain") - [`StripColorBalanceData.invert_slope`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.invert_slope "bpy.types.StripColorBalanceData.invert_slope") - [`StripColorBalanceData.invert_offset`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.invert_offset "bpy.types.StripColorBalanceData.invert_offset") - [`StripColorBalanceData.invert_power`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData.invert_power "bpy.types.StripColorBalanceData.invert_power") |
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   The input geometry containing the hair curves whose radius will be modified.

Replace Radius
:   When enabled, the node replaces the existing radius attribute with a new one.
    When disabled, the new radius is multiplied with the existing value instead.

Radius
:   The base radius value applied to all curves when *Replace Radius* is enabled.
    This sets the overall scale of the hair thickness.

Shape
:   Defines how the radius changes along the curve.
    For example, this can create a tapered profile, with thicker roots and thinner tips.

Factor Min
:   The multiplier applied to the radius at the start (root) of each curve.
    Typically used to control how thick the curve starts.

Factor Max
:   The multiplier applied to the radius at the end (tip) of each curve.
    Typically used to control how thin the curve becomes toward the tip.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Mode
:   Which marker position to use for output.

    Absolute:
    :   Outputs an absolute position of a marker.

    Relative Start:
    :   Outputs the positions of a marker relative to the first marker of a track.

    Relative Frame:
    :   Outputs the positions of a marker relative to the markers of the given *Frame*.

    Absolute Frame:
    :   Outputs the absolute positions of a marker at the given *Frame*.
user: Show practical ways to work with Noise in a Blender add-on or script – include code.

assistant: # Noise

The *Noise* modifier uses a pseudo-random number generator to variably distribute the property along the stroke.

Amplitude
:   The maximum value of the noise. A higher amplitude means a less transparent (more solid) stroke.

Period
:   The period of the noise. This means how quickly the property value can change.
    A higher value means a more smoothly changing color along the stroke.

Seed
:   Seed used by the pseudo-random number generator.

Asymmetric Thickness only
:   Allows the thickness to be distributed unevenly at every point.
    Internally, the stroke is represented as a backbone with a thickness to the right and left side.
    All other thickness shaders make sure that the left and right thickness values are equal.
    For the Noise shader however, a meaningful (and good-looking) result
    can be created by assigning different values to either side of the backbone.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_color_noise_thickness-noise-example.png)

Effect generated with a noise thickness modifier using asymmetric thickness.
user: Describe Known Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Archive Extraction

Extracting Blender’s archive using **7-zip** is not supported. TAR must be used instead. For more details, see issue
[#104070](https://projects.blender.org/blender/blender/issues/104070#issuecomment-1276521).
user: How do I use Icosphere in Blender? Include parameters, examples, warnings and best practices.

assistant: An icosphere is a sphere built from equilateral triangles
and has a more uniform distribution of vertices compared to a UV sphere.
This makes it ideal for sculpting, simulations, or applications where topological regularity is important.

It is created by recursively subdividing the faces of an icosahedron, which is a polyhedron with 20 triangular faces.

Subdivisions
:   Number of recursive subdivision steps.
    Each step splits every triangle into four new triangles, increasing the mesh resolution exponentially.

    - Subdivision Level 1 creates the base icosahedron.
    - Higher levels smooth the surface and increase vertex count.

Radius
:   Distance from the center to the outer surface of the sphere.
user: What is GeometryNodeMeshUVSphere(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeMeshUVSphere(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.GeometryNodeMeshUVSphere(*GeometryNode*)
:   Generate a spherical mesh with quads, except for triangles at the top and bottom

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

assistant: # Introduction

Sculpting and painting offers a more freeform workflow of editing via [brushes](brush/index.html).
There are several [modes](../editors/3dview/modes.html) to do this, each with their own purpose.

- [Sculpting](sculpting/introduction/general.html):
  Change and transform the topology of your mesh.
- [Vertex Paint](vertex_paint/introduction.html):
  Change the color of vertices in the active Color Attribute.
- [Weight Paint](weight_paint/introduction.html):
  Change the weight of vertices in the active vertex group.
- [Texture Paint](texture_paint/introduction.html):
  Change the pixels of the active image texture.
user: Explain Navigating in complete detail according to the official Blender documentation.

assistant: # Navigating

As with most editors, you can:

- Pan the view vertically (channels) and horizontally (time) by dragging `MMB`.
- Zoom in and out by rolling `Wheel` or dragging `Ctrl`-`MMB`.

You can also use the scrollbars for this.
user: Explain Surface in complete detail according to the official Blender documentation.

assistant: Direct Light
:   This option limits the maximum light intensity a surface can reflect.
    It reduces [Aliasing](../../../glossary/index.xhtml#term-Aliasing) noise and [Fireflies](../../../glossary/index.xhtml#term-Fireflies) at the cost of accuracy.
    Setting this option to 0.0 disables clamping altogether.
    Lower values have a greater effect on the resulting image than higher values.

Indirect Light
:   Similar to **Direct Light** but limits the maximum light intensity reflected using ray-tracing and light-probes.
    This also limits the intensity of the world lighting since it is considered as indirect light.
user: What is Application Translations (bpy.app.translations) and how is it used in Blender Python scripting?

assistant: # Application Translations (bpy.app.translations)

This object contains some data/methods regarding internationalization in Blender, and allows every py script
to feature translations for its own UI messages.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Radius
:   Control newly added point’s radius.

Stroke Placement
:   The [Stroke Placement](../../draw/stroke_placement.html) of newly added points.

Drawing Plane
:   The [Drawing Planes](../../draw/drawing_planes.html) of newly added points.
user: Describe Shrinkwrap Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Shrinkwrap Type Items

NEAREST_SURFACEPOINT:
:   Nearest Surface Point.

    Shrink the mesh to the nearest target surface.

PROJECT:
:   Project.

    Shrink the mesh to the nearest target surface along a given axis.

NEAREST_VERTEX:
:   Nearest Vertex.

    Shrink the mesh to the nearest target vertex.

TARGET_PROJECT:
:   Target Normal Project.

    Shrink the mesh to the nearest target surface along the interpolated vertex normals of the target.
user: Describe Toggle Local View from the Blender manual or Python API, including usage steps and snippets.

assistant: Global view shows all 3D objects in the scene. Local view isolates the selected object(s)
so that they are the only ones visible in the viewport. This is useful for working on
objects that are obscured by others, or to speed up the viewport performance in heavy scenes.
Local view is contextual, meaning that it can be set per 3D Viewport.

You can toggle between *Global* and *Local View* by selecting the option
from the View menu or using the shortcut `NumpadSlash`.

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_local-view_local1.png   Global View. | ../../../_images/editors_3dview_navigate_local-view_local2.png   Local View. |

### Remove from Local View

Objects can be removed from Local View by selecting them and using the *Remove from Local View* operator.
If the last remaining object is removed, Blender will automatically return to the Global View.
user: Give a detailed overview of Set Curve Radius Node: syntax, arguments, return values, common patterns.

assistant: # Set Curve Radius Node

[image reference removed]

The *Set Curve Radius* controls the radius of the curve, used for operations like the size of the profile
in the [Curve to Mesh](../operations/curve_to_mesh.xhtml) node. The value is set for
every control point, and is then interpolated to each evaluated point in between the control points.

The input node for this data is the [Radius node](../../geometry/read/radius.xhtml).
user: What is BlendDataSpeakers(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BlendDataSpeakers(bpy_struct)

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

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

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

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

        Returns:
        :   New speaker data-block

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

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

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

    tag(*value*)
    :   tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Tools for applying effects on the entire unmasked and visible mesh.

[Mesh Filter](tools/mesh_filter.xhtml)
:   Apply a deformation to all unmasked vertices.

[Cloth Filter](tools/cloth_filter.xhtml)
:   Applies a cloth simulation to all unmasked vertices.

[Color Filter](tools/color_filter.xhtml)
:   Changes the active color attribute on all unmasked vertices.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Fill Type
:   How the circles at the top and bottom are filled with faces when their radius is larger than zero.

    None:
    :   Do not fill the circles.

    N-Gon:
    :   Fill the innermost circles with a single face.

    Triangles:
    :   Fill the innermost circles with triangles connected to a vertex in the center.
user: Give a detailed overview of Fix to Camera: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Also known as “bake to camera”, this operator will ensure selected objects/bones
remain static (relative to the camera) on unkeyed frames.

This is done by generating new keys. These keys will be of [type
‘Generated’](../../../animation/keyframes/introduction.xhtml#keyframe-type) so that it remains clear which keys were manually
created, and which were generated. This way the tool can be re-run to
re-generate the keys.

1. Ensure your animation is keyed using constant interpolation. If this is not
   the case yet, bake your animation (at least the transform channels). This
   tool does _not_ work with the [“Stepped” F-Curve modifier](../../graph_editor/fcurves/modifiers.xhtml#bpy-types-fmodifierstepped)
2. Choose which of the Location/Rotation/Scale channels you want to fix to the
   camera. When unsure, make sure they are all checked.
3. Press the “Fix to Camera” button.

To undo the effect of the “Fix to Camera” operator, click on the trash bin
button. That will remove all the generated keys in either the scene range or the
frame range.

The tool operates on the scene frame range, or on the preview range if that is
active. Keys outside that range are ignored, both when fixing to the camera and
when removing generated keys.

### Limitations

Pasting a transform adjusts the Object/Bone’s location, rotation, and
scale. This means that when copying a skewed transform, this skew is lost.

If there are constraints on the Object/Bone, the resulting visual transformation
may not be the same as the pasted one. To give a concrete example: if you have a
constraint that adds a rotation, it will always add that rotation on top of the pasted transform.
user: What is Setting Up Materials and how is it used in Blender Python scripting?

assistant: Grease Pencil materials can be created in the [Material properties](../../editors/properties_editor.xhtml)
as any other materials in Blender.
See [Material assignment](../../render/materials/assignment.xhtml) for more information.

The 3D Viewport can be set to Material Preview or Rendered shading,
to interactively preview how the material looks in the scene.

Grease Pencil materials are data-blocks that can be [assigned](../../render/materials/assignment.xhtml)
to one or more objects, and different materials can be assigned to different strokes.

In Grease Pencil the [brush](../modes/draw/brushes/index.xhtml)
settings together with the material used will define the look and feel of the final strokes.

[Materials slots](properties.xhtml#gp-material-slots) also have some extra controls
that help to work with materials while drawing or editing lines.
user: What is Snap and how is it used in Blender Python scripting?

assistant: [Mesh snapping](../../../editors/3dview/controls/snapping.html) also works with curve components.
Both control points and their handles will be affected by snapping,
except for within itself (other components of the active curve).
Snapping works with 2D curves but points will be constrained to the local XY axes.
user: Explain Fairing in complete detail according to the official Blender documentation.

assistant: These operators smooths geometry patches based of a [Face set](face_sets.xhtml).

Fair Positions
:   Creates a perfectly flat and smooth geometry patch from the face set.
    This is the ideal way to trim parts of your mesh
    if the vertex count is too high for other operations,
    or the vertex IDs must not be altered
    (Like when using [Multires](../../../modeling/modifiers/generate/multiresolution.xhtml) sculpting).

Fair Tangency
:   Creates a smooth as possible geometry patch from the face set
    by minimizing changes in vertex [tangents](../../../glossary/index.xhtml#term-Tangent).
    This is ideal for creating smooth curved surfaces on complex topology,
    where just using the smooth brush will not lead to desired results
user: Describe Installing Legacy Add-ons from the Blender manual or Python API, including usage steps and snippets.

assistant: To install legacy add-ons, click the *Install from Disk* menu item and select the add-on’s
`.py` file (if it has only one such file) or its `.zip` file.

The add-on will not be automatically enabled after installation; click the checkbox to do that.

Refresh
:   Scans the [Add-on Directory](../../advanced/blender_directory_layout.xhtml#blender-directory-layout) for new add-ons.
user: How do I use PaletteColors(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # PaletteColors(bpy_struct)

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

*class* bpy.types.PaletteColors(*bpy_struct*)
:   Collection of palette colors

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

    new()
    :   Add a new color to the palette

        Returns:
        :   The newly created color

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

    remove(*color*)
    :   Remove a color from the palette

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

    clear()
    :   Remove all colors from the palette

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

assistant: # VIEW3D_AST_brush_gpencil_weight(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_gpencil_weight(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *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 GeometryNodeCurveSplineType(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeCurveSplineType(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.GeometryNodeCurveSplineType(*GeometryNode*)
:   Change the type of curves

    spline_type
    :   The curve type to change the selected curves to

        Type:
        :   enum in [Curves Type Items](bpy_types_enum_items/curves_type_items.html#rna-enum-curves-type-items), default `'POLY'`

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

assistant: [image reference removed]

Image menu in the Header of the Image editor.

Popup menus list [Operators](../../operators.xhtml) which can be executed by selecting with `LMB`
or using the generated shortcut indicated by the underlined character of the operator name.
All menu entries show any relevant shortcut keys, which can be executed without opening the menu.

All popup menus can be searched by pressing `Spacebar` and typing the name of the operator in the menu.
If a popup menu has “Search” as one of the items, the menu can be searched without having to press `Spacebar`
first.

All popup menus of an editor can be searched using the [Menu Search](../../operators.xhtml#bpy-ops-wm-search-menu) feature.

### Collapsing Menus

Sometimes it’s helpful to gain some extra horizontal space in the header by collapsing menus.
This can be accessed from the header context menu:
click `RMB` on the header and uncheck the *Show Menus checkbox*.

|  |  |
| --- | --- |
| ../../../_images/interface_controls_buttons_menu_header_uncheck_show_menus_checkbox.png   Right-click on any of the header menus. | ../../../_images/interface_controls_buttons_menus_header-menu-collapsed.png   Access the menu from the collapsed icon. |
user: What is ID Node and how is it used in Blender Python scripting?

assistant: # ID Node

[image reference removed]

The *ID* node gives an integer value indicating the stable random identifier of each element on the point domain,
which is stored in the `id` attribute.

The node to set this data is the [Set ID Node](../write/set_id.html) node.
user: What is Options and how is it used in Blender Python scripting?

assistant: Clear Delta
:   Clear the [delta transform](../properties/transforms.xhtml#bpy-types-object-delta) in addition to clearing the primary transforms.
    (Appears in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.)
user: What is Decorators and how is it used in Blender Python scripting?

assistant: # Decorators

Decorators are small buttons that appear to the right of other buttons and show the state of the property.
Decorators may appear next to number fields, menus,
and checkboxes to indicate the property can be [animated](../../../animation/index.xhtml).

[image reference removed]

Decorators indicating different property states.

Clicking on the decorator dot icon will add a [Keyframe](../../../animation/keyframes/index.xhtml) to that property.
Clicking the rhombus icon again will remove the keyframe.
A solid rhombus icon indicates there is a keyframe on the current frame,
while a non-solid rhombus icon indicates that the property has a keyframe on another frame.
Clicking the non-solid rhombus icon will create a keyframe on the current frame with the current property value.

If a property is being [driven](../../../animation/drivers/index.xhtml)
by another, the decorator shows the driver icon.

Decorators make it quick and easy to glance over properties and see their state.
user: Describe Space File Browse Mode Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Space File Browse Mode Items

FILES:
:   File Browser.

    Built-in file manager for opening, saving, and linking data.

ASSETS:
:   Asset Browser.

    Manage assets in the current file and access linked asset libraries.
user: How do I use Line Art in Blender? Include parameters, examples, warnings and best practices.

assistant: # Line Art

[image reference removed]

Line Art material properties.

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

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

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

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

assistant: |  |  |
| --- | --- |
| - [`WindowManager.popover_begin__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popover_begin__internal "bpy.types.WindowManager.popover_begin__internal") | - [`WindowManager.popover_end__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popover_end__internal "bpy.types.WindowManager.popover_end__internal") |
user: What is Swapping Contents and how is it used in Blender Python scripting?

assistant: You can swap the contents of two areas by pressing `Ctrl`-`LMB`
on one of the corners of the initial area, dragging towards the target area,
and releasing the mouse there. The two areas do not need to be side-by-side,
though they must be inside the same window.
user: What is LockedTrackConstraint(Constraint) and how is it used in Blender Python scripting?

assistant: # LockedTrackConstraint(Constraint)

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

*class* bpy.types.LockedTrackConstraint(*Constraint*)
:   Point toward the target along the track axis, while locking the other axis

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    lock_axis
    :   Axis that points upward

        Type:
        :   enum in [`'LOCK_X'`, `'LOCK_Y'`, `'LOCK_Z'`], default `'LOCK_X'`

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    track_axis
    :   Axis that points to the target object

        Type:
        :   enum in [`'TRACK_X'`, `'TRACK_Y'`, `'TRACK_Z'`, `'TRACK_NEGATIVE_X'`, `'TRACK_NEGATIVE_Y'`, `'TRACK_NEGATIVE_Z'`], default `'TRACK_X'`

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        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: Give a detailed overview of UVWarpModifier(Modifier): syntax, arguments, return values, common patterns.

assistant: # UVWarpModifier(Modifier)

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

*class* bpy.types.UVWarpModifier(*Modifier*)
:   Add target position to UV coordinates

    axis_u
    :   Pole axis for rotation

        Type:
        :   enum in [Axis Xyz Items](bpy_types_enum_items/axis_xyz_items.html#rna-enum-axis-xyz-items), default `'X'`

    axis_v
    :   Pole axis for rotation

        Type:
        :   enum in [Axis Xyz Items](bpy_types_enum_items/axis_xyz_items.html#rna-enum-axis-xyz-items), default `'Y'`

    bone_from
    :   Bone defining offset

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

    bone_to
    :   Bone defining offset

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

    center
    :   Center point for rotate/scale

        Type:
        :   float array of 2 items in [-inf, inf], default (0.5, 0.5)

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    object_from
    :   Object defining offset

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

    object_to
    :   Object defining offset

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

    offset
    :   2D Offset for the warp

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

    rotation
    :   2D Rotation for the warp

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

    scale
    :   2D Scale for the warp

        Type:
        :   float array of 2 items in [-inf, inf], default (1.0, 1.0)

    uv_layer
    :   UV map name

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

    vertex_group
    :   Vertex group name

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

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

assistant: # Sinus Displacement

The *Sinus Displacement* modifier adds a sinusoidal displacement to the stroke.

Wavelength
:   How wide the undulations are along the stroke.

Amplitude
:   How high the undulations are across the stroke.

Phase
:   Allows “offsetting” (“moving”) the undulations along the stroke.

[image reference removed]

Sinus Displacement modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_Sinus.zip)).
user: Show practical ways to work with Paste File in a Blender add-on or script – include code.

assistant: Inserts text from and external text file.
This will bring up a [File Browser](../../editors/file_browser.html) for navigating to a valid UTF-8 file.
As usual, be careful that the file does not have too many characters,
as interactive response will slow down.
user: What is Shape Key Editor and how is it used in Blender Python scripting?

assistant: # Shape Key Editor

The *Shape Key Editor* displays the [shape keys](../../../animation/shape_keys/introduction.html) of the
active object and allows you to create and adjust keyframes for their
[influence values](../../../animation/shape_keys/shape_keys_panel.html#bpy-types-shapekey-value).
This editor is a specialized mode of the [Dope Sheet](../introduction.html),
focused specifically on shape key animation.

Each row represents a shape key, and each keyframe marker corresponds to a point where the
shape key’s value changes over time.
This provides an efficient way to time and refine facial expressions, morph targets,
and other mesh deformations driven by shape keys.

Additional shape key properties, such as names, values, and relative settings,
can be viewed and edited in the *Sidebar*.

[image reference removed]

The Shape Key Editor.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Mean
:   The mean is the average value of all image pixels in specified channel.
    It represents the overall brightness of the image and can be used as such
    for setups that depend on how “bright” or “dark” the input is.

Standard Deviation
:   How much pixel values differ from the mean.
    A low standard deviation indicates that the pixel values tend to be very close to the mean.
    A high standard deviation indicates that the values are spread out over a large range of values.
user: Provide the full official documentation entry for Limitations, preserving all code examples.

assistant: # Limitations

EEVEE’s goal is to be an interactive render engine. Some features may not be there yet or
may be impossible to implement into EEVEE’s architecture without compromising performance.

Here is a rather exhaustive list of all the limitations you can expect while working with EEVEE.
user: Describe Subdivide from the Blender manual or Python API, including usage steps and snippets.

assistant: Subdivides the selected segments (grid lines) by creating additional, evenly spaced control points in the middle.
These new points then give more fine-grained control over the surface’s shape.

The selection must consist of complete rows or columns of the control point grid.

If not all control points of the surface are selected, it will be subdivided in one direction.
If all control points are selected, it will be subdivided in both directions.

Number of Cuts
:   The number of control points to add in each segment.
user: Show practical ways to work with Common Physics Settings in a Blender add-on or script – include code.

assistant: Size
:   Sets the size of the particles.

Random Size
:   Give the particles a random size variation.

Mass
:   Specify the mass of the particles.

Multiply Mass with Particle Size
:   Causes larger particles to have larger masses.
user: Describe Workflow from the Blender manual or Python API, including usage steps and snippets.

assistant: The process of multi camera editing can be rather easy in the Video Sequencer if properly setup.
The following guide shows the basic steps to setup a basic multi camera editing workflow.

1. First you are going to want to add in each of your video strips.
2. Next, you will want to sync all your cameras by either using
   [Audio Waveforms](../sound.xhtml) or by the movement of objects.
3. Split the editor into many [Previews](../../../../../editors/video_sequencer/preview/index.xhtml), one for each input track.
   Then change the [Display Channel](../../../../../editors/video_sequencer/preview/sidebar.xhtml#bpy-types-spacesequenceeditor-display-channel)
   of each of the previews to the channel number of the input track.
4. Add a Multicam Selector strip *above* all the video channel tracks.

   After completing these steps you should get something similar to the following image:

   [image reference removed]

   Multi-camera editing setup.
5. Now select the Multicam strip, if you take a look at the strip options (in the Sidebar),
   you will notice, that Multicam is a rather simple effect strip:
   It just takes a selected channel as its input. That is all.
   The magic comes with the convenient keyboard layout.
6. When you select the Multicam strip, the keys `1` to `9` are mapped to the cut buttons.
   So, select the Multicam strip and start playback and press the keys
   for the correct input while watching the individual cameras.
7. You will end up with a small Multicam Selector strip for every cut.

In reality, it boils down to: watch a few seconds to see, what is coming,
watch it again and do a rough cut using the number keys.
Then fine-tune the placement by selecting the outer handles of two neighboring Multicam for A/B rolling.
user: Describe Getting Started from the Blender manual or Python API, including usage steps and snippets.

assistant: The object to be painted on must first be [unwrapped](../../modeling/meshes/uv/unwrapping/introduction.xhtml).
UVs can be added traditionally, with standard [Unwrapping Tools](../../modeling/meshes/editing/uv.xhtml),
or by adding [Simple UVs](tool_settings/texture_slots.xhtml#bpy-ops-paint-add-simple-uvs) in Texture Paint mode.

Once you have unwrapped your model to a UV map, you can begin the texturing process.
To use texture paint you may do any of the following:

- Activate the Texture Paint workspace. Here the 3D Viewport has the Texture Paint Mode enabled
  and the Image Editor is already switched to Paint mode.
- In the 3D Viewport, select Texture Paint Mode from the mode selector in the header,
  and you can paint directly onto the mesh.
- In the Image Editor, switch the mode to Paint (shown in the image to the right).

[image reference removed]

Enabling Paint mode.

Once you enable Texture Painting, your mouse becomes a brush.
As soon as you enable Texture Painting or switch to Texture Paint Mode,
different tools become available in the Toolbar.

In the Image Editor, you paint on a flat canvas that is wrapped around the mesh using UV coordinates.
Any changes made in the Image Editor show up immediately in the 3D Viewport, and vice versa.

To work with the UV layout (for example, to move coordinates) you must use the [UV Editor](../../editors/uv/index.xhtml).

A full complement of brushes and colors can be selected from the Sidebar region in the Image Editor.
Brush changes made in either panel are immediately reflected in the other panel.
However, the modified texture will **not** be saved automatically;
you must explicitly do so with [Save Image](../../editors/image/editing.xhtml#bpy-ops-image-save).
user: Give a detailed overview of Extrapolation Mode: syntax, arguments, return values, common patterns.

assistant: Changes how the curve behaves before its first keyframe and after its last keyframe.

Constant:
:   [image reference removed]

    Constant extrapolation.

    Continue in a straight line, keeping the same value as the first/last keyframe.
    This is the default.

Linear:
:   [image reference removed]

    Linear extrapolation.

    Continue in a straight line, keeping the same slope as on the first/last keyframe.

Make Cyclic:
:   Repeat the whole curve. This works by adding a [Cycles modifier](../fcurves/modifiers.xhtml#bpy-types-fmodifiercycles).

Clear Cyclic:
:   Remove the above modifier, making the curve non-repeating again.