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

assistant: # GreasePencilFrames(bpy_struct)

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

*class* bpy.types.GreasePencilFrames(*bpy_struct*)
:   Collection of Grease Pencil frames

    new(*frame_number*)
    :   Add a new Grease Pencil frame

        Parameters:
        :   **frame_number** (*int in* *[**-1048574**,* *1048574**]*) – Frame Number, The frame on which the drawing appears

        Returns:
        :   The newly created frame

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

    remove(*frame_number*)
    :   Remove a Grease Pencil frame

        Parameters:
        :   **frame_number** (*int in* *[**-1048574**,* *1048574**]*) – Frame Number, The frame number of the frame to remove

    copy(*from_frame_number*, *to_frame_number*, *\**, *instance_drawing=False*)
    :   Copy a Grease Pencil frame

        Parameters:
        :   - **from_frame_number** (*int in* *[**-1048574**,* *1048574**]*) – Source Frame Number, The frame number of the source frame
            - **to_frame_number** (*int in* *[**-1048574**,* *1048574**]*) – Frame Number of Copy, The frame number to copy the frame to
            - **instance_drawing** (*boolean**,* *(**optional**)*) – Instance Drawing, Let the copied frame use the same drawing as the source

        Returns:
        :   The newly copied frame

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

    move(*from_frame_number*, *to_frame_number*)
    :   Move a Grease Pencil frame

        Parameters:
        :   - **from_frame_number** (*int in* *[**-1048574**,* *1048574**]*) – Source Frame Number, The frame number of the source frame
            - **to_frame_number** (*int in* *[**-1048574**,* *1048574**]*) – Target Frame Number, The frame number to move the frame to

        Returns:
        :   The moved frame

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with List View in a Blender add-on or script – include code.

assistant: # List View

[image reference removed]

List view with expanded Filtering Options panel.

This control is useful for managing lists of items.
In addition to the main list, there is a Filtering panel on the bottom
(hidden by default) and modification buttons on the right.

Select
:   To select an item, click `LMB` on it.

Rename
:   By double-clicking on an item, you can edit its name via a text field.
    This can also be achieved by clicking it with `Ctrl`-`LMB`.

Resize
:   The list view can be resized to show more or fewer items.
    Hover the mouse over the handle (::::), then click and drag to expand or shrink the list.

Filter
:   Click the *Show filtering options* button (triangle on bottom left) to show or hide the filter option panel.

    Search `Ctrl`-`F`
    :   Filters the list to only show items containing a certain term.

    Invert
    :   Toggle between including items that match the search term and those that do not contain the search term.

    Sort by Name
    :   This button switches between alphabetical and non-alphabetical ordering.

    Reverse
    :   Sort objects in ascending or descending order. This also applies to alphabetical sorting, if selected.

On the right of the list view are list modification buttons:

(Add)
:   Adds a new item.

(Remove)
:   Removes the selected item.

(Specials)
:   A menu with operators to edit list entries.

/ Move
:   Moves the selected item up/down one position.
user: Describe General from the Blender manual or Python API, including usage steps and snippets.

assistant: Hide
:   Hides the bone in the 3D Viewport. When this is unchecked, the bone’s
    visibility is determined by the visibility of its [bone collections](relations.xhtml#bpy-types-bone-collections).

Display As
:   This controls the way the selected bones appear in the 3D Viewport.
    This overrides the [Display Type](../../properties/display.xhtml#bpy-types-armature-display-type) of the armature.

    |  |  |
    | --- | --- |
    | ../../../../_images/animation_armatures_properties_display_octahedral.png   Octahedral bone display. | ../../../../_images/animation_armatures_properties_display_stick.png   Stick bone display. |
    | ../../../../_images/animation_armatures_properties_display_b-bone.png   B-Bone bone display. | ../../../../_images/animation_armatures_properties_display_envelope.png   Envelope bone display. |

    Armature Defined:
    :   Use display mode from armature.

    Octahedral:
    :   Display bones as octahedral shape.

    Stick:
    :   Display bones as simple 2D lines with dots.

    B-Bone:
    :   Display bones as boxes, showing subdivision and B-Splines.

    Envelope:
    :   Display bones as extruded spheres, showing deformation influence volume.

    Wire:
    :   Display bones as thin wires, showing subdivision and B-Splines.
user: What is Usage and how is it used in Blender Python scripting?

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Curve tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.xhtml#grease-pencil-draw-common-options) for more information.

### Creating Curves

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can tweak the curve using two cyan Bézier like manipulators.
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can hold `Shift` to use only one manipulator to tweak the curve (like the Arc tool),
use `Alt` to create the arc from a center point.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel` will increase
or decrease the amount of points in the final curve.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_curve_example-01.png   click and dragging the start point. | ../../../../_images/grease-pencil_modes_draw_tools_curve_example-02.png   Tweaking curve with the manipulators. | ../../../../_images/grease-pencil_modes_draw_tools_curve_example-03.png   The curve after confirming. |

### Extruding

Before confirming you can use `E` to extrude the end point of the curve
to generate multiple connected curves.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_curve_extrude-01.png   End point extruding. | ../../../../_images/grease-pencil_modes_draw_tools_curve_extrude-02.png   Tweaking the last curve with the manipulators. | ../../../../_images/grease-pencil_modes_draw_tools_curve_extrude-03.png   The connected curves after confirming. |
user: What is Animating Audio Track Properties and how is it used in Blender Python scripting?

assistant: To animate Sound strips simply hit `I` over any of its values.
Examples of animating an audio strip are to fade in/out background music or to adjust volume levels.
Layered/crossed Sound strips are added together;
the lower channel does not override and cut out higher channels (unlike image and video strips).
This makes Blender an audio mixer.
By adding audio tracks and using the curves to adjust each tracks sound level,
you have an automated dynamic multi-track audio mixer!
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Data Type
:   The type of data stored in the grid (e.g. *Float*, *Integer*, *Boolean*, or *Vector*).
    Determines the expected data type of the *Grid* input and ensures that the
    grid is stored correctly in the volume container.
user: Describe Placement from the Blender manual or Python API, including usage steps and snippets.

assistant: If Backface Culling is not enabled, snapping the light probe plane to the planar surface
will effectively capture the underside of the surface.

You can manually move the light probe plane above the surface enough for it to not appear in the capture.
Alternatively you can disable the light probe visibility in the object visibility panel.
user: Explain Bevel Modifier in complete detail according to the official Blender documentation.

assistant: # Bevel Modifier

[[image reference removed]](../../../_images/modeling_modifiers_generate_bevel_panel.png)

The Bevel modifier.

The *Bevel* modifier bevels the edges of the mesh it is applied to,
with some control of how and where the bevel is applied to the mesh.

It is a non-destructive alternative to
the [Bevel Operation](../../meshes/editing/edge/bevel.html) in Edit Mode.

Side views of a cube.

|  |  |
| --- | --- |
| <../../../_images/modeling_modifiers_generate_bevel_square-not.png>   Not beveled. | <../../../_images/modeling_modifiers_generate_bevel_square.png>   Beveled. |
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`BoidRule.name`](bpy.types.BoidRule.html#bpy.types.BoidRule.name "bpy.types.BoidRule.name") - [`BoidRule.type`](bpy.types.BoidRule.html#bpy.types.BoidRule.type "bpy.types.BoidRule.type") | - [`BoidRule.use_in_air`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_in_air "bpy.types.BoidRule.use_in_air") - [`BoidRule.use_on_land`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_on_land "bpy.types.BoidRule.use_on_land") |
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: 1. Choose File ‣ New ‣ Video Editing to open the template.
2. Use the File Browser to locate your media files.
3. Drag and drop media (movies, images, or sounds) into the Sequencer area.
4. Arrange and edit the strips as needed.
5. Use Render ‣ Render Animation to export your final video.

This template offers an efficient starting point for editing projects, combining layout, settings,
and workflow elements tailored for video production.
user: Describe Reload Library from the Blender manual or Python API, including usage steps and snippets.

assistant: When the Outliner is in the *Blender File* [Display Mode](../../editors/outliner/interface.xhtml#bpy-types-spaceoutliner-display-mode),
you can right-click a linked blend-file and choose *Reload* to immediately update
the current blend-file with the latest version of the linked data-blocks,
without having to reopen the file.
user: How do I use Relative File Paths in Blender? Include parameters, examples, warnings and best practices.

assistant: Blender’s relative file paths are not compatible with standard Python modules such as `sys` and `os`.
Built-in Python functions don’t understand Blender’s `//` prefix which denotes the blend-file path.

A common case where you would run into this problem is when exporting a material with associated image paths:

```
>>> bpy.path.abspath(image.filepath)
```

When using Blender data from linked libraries there is an unfortunate complication
since the path will be relative to the library rather than the open blend-file.
When the data block may be from an external blend-file pass the library argument from the [`bpy.types.ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID").

```
>>> bpy.path.abspath(image.filepath, library=image.library)
```

These returns the absolute path which can be used with native Python modules.
user: How do I use Movement in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Boid Movement settings.

Boids avoid objects with Collision enabled, move toward goals, and flee from “predators” based on the *Boid Brain*.
Their behavior changes depending on whether they are in the air or on land.

Allow Flight
:   Enables movement in the air.

Allow Land
:   Enables movement on land.

Allow Climbing
:   Enables climbing toward goal objects.

Max Air Speed
:   The maximum velocity boids can achieve while in the air.

Min Air Speed
:   The minimum velocity boids maintain while flying.

Max Air Acceleration
:   Controls how quickly boids can change direction in the air, expressed as a percentage of their maximum velocity.
    Higher values result in more agile movements.

Max Air Angular Velocity
:   Limits how sharply boids can turn in the air, expressed as a percentage of 180 degrees.
    Lower values create smoother curves during flight.

Air Personal Space
:   The radius of personal space for boids in the air, as a percentage of their particle size.
    Larger values reduce crowding in swarms.

Landing Smoothness
:   Adjusts how softly boids land on surfaces.
    Higher values ensure gradual transitions when landing.

Max Land Speed
:   The maximum velocity boids can achieve on land.

Jump Speed
:   The velocity boids achieve during jumps.

Max Land Acceleration
:   Controls how quickly boids can change direction on land, expressed as a percentage of their maximum velocity.

Max Land Angular Velocity
:   Limits how sharply boids can turn on land, expressed as a percentage of 180 degrees.
    Lower values create smoother, less abrupt turns.

Land Personal Space
:   The radius of personal space for boids on land, as a percentage of their particle size.
    Larger values reduce crowding in herds or groups.

Land Stick Force
:   Determines the strength of a force required to influence boids on land.
    Use lower values to allow boids to move more freely when interacting with forces.

Collision Collection
:   Restricts collisions to objects within the specified collection.
    This is useful for limiting interactions to certain objects or environments.
user: Provide the full official documentation entry for Action Menu, preserving all code examples.

assistant: Merge Animation
:   This operator merges the animation of all selected objects into the animation of the
    active object. Since the data is moved and not copied, the source Actions might end up
    empty and without users.
    Note that this will not only merge the object level Action, but Actions on related data-blocks
    as well (See [Related data-blocks](../../../animation/actions.xhtml#working-with-actions)). As a result of that
    this operator can also be used to merge Actions of one Object. For example
    Translation & Rotation and animation on Shape Keys.

Separate Slots
:   This splits all Slots of the Action on the active Object into separate Actions.
    All users of those Slots will be re-assigned to their respective Action and
    the newly created Actions are named after the Slot.
    The source Action will not be deleted, but might end up with 0 users if no
    [Fake User](../../../files/data_blocks.xhtml#data-system-datablock-fake-user) is set.

Move Slots to new Action
:   This moves Slots selected in the [Channels Region](../../graph_editor/channels/introduction.xhtml#editors-graph-editor-channels-region)
    to a newly created Action. All users of those Slots are re-assigned to the new Action.
    If more than one Slot is selected, all Slots are moved into a single Action.

Push Down Action
:   Creates a new NLA track below the Action Track and moves the active action into it.
    This is the same as clicking [Push Down Action](../../nla/tracks.xhtml#bpy-ops-nla-action-pushdown)
    in the NLA editor.

Stash Action
:   Creates a new *muted* NLA track at the bottom of the NLA tracks and moves the active action into it.
    In effect, this sets the action aside for later use, disabling it so it no longer
    affects the animation. Later, you can choose to either unmute it again or delete it.

    If you click *New Action* in the data-block menu for an object that already has an
    active action, that previous action will be stashed automatically.
user: How do I use Separate in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Separate* operator removes the selected nodes from a node group
and places them in the parent node tree.
This is useful when nodes need to be edited outside of a group for clarity or reuse.

Copy
:   Duplicates the selected nodes into the parent node tree,
    while keeping the originals inside the group.
    This is useful when you want to reuse nodes outside of the group
    but still preserve the group definition.

Move
:   Moves the selected nodes to the parent node tree,
    removing them from the original group.
    This is useful when simplifying a group or exposing its contents directly.
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Space.type`](bpy.types.Space.html#bpy.types.Space.type "bpy.types.Space.type") | - [`Space.show_locked_time`](bpy.types.Space.html#bpy.types.Space.show_locked_time "bpy.types.Space.show_locked_time") - [`Space.show_region_header`](bpy.types.Space.html#bpy.types.Space.show_region_header "bpy.types.Space.show_region_header") |
user: How do I use Armature Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Armature Modifier

The *Armature* Modifier is used for building skeletal systems for animating
the poses of characters and anything else which needs to be posed.

By adding an armature to an object,
this object can be deformed accurately so that geometry does not have to be animated by hand.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`BlendData.annotations`](bpy.types.BlendData.html#bpy.types.BlendData.annotations "bpy.types.BlendData.annotations") - [`BlendDataAnnotations.new`](bpy.types.BlendDataAnnotations.html#bpy.types.BlendDataAnnotations.new "bpy.types.BlendDataAnnotations.new") - [`BlendDataAnnotations.remove`](bpy.types.BlendDataAnnotations.html#bpy.types.BlendDataAnnotations.remove "bpy.types.BlendDataAnnotations.remove") - [`MovieClip.annotation`](bpy.types.MovieClip.html#bpy.types.MovieClip.annotation "bpy.types.MovieClip.annotation") - [`MovieTrackingTrack.annotation`](bpy.types.MovieTrackingTrack.html#bpy.types.MovieTrackingTrack.annotation "bpy.types.MovieTrackingTrack.annotation") | - [`NodeTree.annotation`](bpy.types.NodeTree.html#bpy.types.NodeTree.annotation "bpy.types.NodeTree.annotation") - [`Scene.annotation`](bpy.types.Scene.html#bpy.types.Scene.annotation "bpy.types.Scene.annotation") - [`SpaceImageEditor.annotation`](bpy.types.SpaceImageEditor.html#bpy.types.SpaceImageEditor.annotation "bpy.types.SpaceImageEditor.annotation") - [`SpaceSequenceEditor.annotation`](bpy.types.SpaceSequenceEditor.html#bpy.types.SpaceSequenceEditor.annotation "bpy.types.SpaceSequenceEditor.annotation") |
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: - A single colored texture (0.5, 0.0, 0.5) creates a force in the direction of the positive Y axis,
  e.g. hair is orientated to the Y axis.
- A blend texture with color ramp can be used to created a force “plane”. E.g. on the left side (0.5, 0.5, 0.5),
  on the right side (1.0, 0.5, 0.5) you have a force plane perpendicular to XY (i.e. parallel to Z).
  If you use an object for the coordinates, you can use the object to push particles around.
- An animated wood texture can be used to create a wave like motion.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

UI for a Curve Guide force field.

Free
:   Fraction of particle life time, that is not used for the curve.

Falloff Power
:   This setting governs the strength of the guide between *Min Distance* and *Max Distance*.
    A falloff of 1 means a linear progression.

Additive
:   If you use *Additive*, the speed of the particles is also evaluated depending on the falloff.

Weights
:   Use Curve weights to influence the particle influence along the curve.

Clumping Amount
:   The particles come together at the end of the curve (1) or they drift apart (-1).

Shape
:   Defines the form in which the particles come together.
    +0.99: the particles meet at the end of the curve.
    0: linear progression along the curve. -0.99: the particles meet at the beginning of the curve.

Min Distance
:   The distance from the curve, up to where the force field is effective with full strength.
    If you have a falloff of 0, this parameter will have no effect,
    because the field is effective with full strength up to *Max Distance* (or the infinity).
    *Min Distance* is shown with a circle at the endpoints of the curve in the 3D Viewport.

Max Distance
:   The maximum influence radius. Shown by an additional circle around the curve object.

### Kink

Type
:   Changes the shape that the particles can take.

    None:

    Braid:

    Curl:
    :   The radius of the influence depends on the distance of the curve to the emitter.

    Radial:
    :   A three-dimensional, standing wave.

    Roll:
    :   A one-dimensional, standing wave.

    Rotation:

    Wave:
    :   A two-dimensional, standing wave.

    It is not so easy to describe the resulting shapes, so have a look at the example below.

    [[image reference removed]](../../../../_images/physics_forces_force-fields_types_curve-guide_kink.jpg)

    Kink options of a curve guide. From left to right: Radial, Wave, Braid, Roll.
    [Animation](https://vimeo.com/1866538).

Axis
:   Which axis to use for the offset.

Frequency
:   The frequency of the offset.

Shape
:   Adjust the offset to the beginning/end.

Amplitude
:   The Amplitude of the offset.
user: What is NodeGeometryViewerItem(bpy_struct) and how is it used in Blender Python scripting?

assistant: # NodeGeometryViewerItem(bpy_struct)

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

*class* bpy.types.NodeGeometryViewerItem(*bpy_struct*)
:   auto_remove
    :   Remove the item automatically when it is unlinked

        Type:
        :   boolean, default False

    color
    :   Color of the corresponding socket type in the node editor

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

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

    socket_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The first two sockets are the minimum output.

Image
:   Outputs the entire image in the specified color space.

Alpha
:   The alpha value taken from the movie or image.

Offset X
:   The X offset value from the footage camera or tracking.

Offset Y
:   The Y offset value from the footage camera or tracking.

Scale
:   The scale of the image taken from the footage camera or tracking.

Angle
:   The lens angle taken from the footage camera or tracking.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Channel
:   Selects which color values are used to calculate analytics.

    Combined:
    :   Calculate values based on the red, green, and blue channels.

    Red:
    :   Calculate values based on the red channel.

    Green:
    :   Calculate values based on the green channel.

    Blue:
    :   Calculate values based on the blue channel.

    Luminance:
    :   Calculate values based on the [Luminance](../../../glossary/index.xhtml#term-Luminance) of the image.
user: Provide the full official documentation entry for CurveProfilePoint(bpy_struct), preserving all code examples.

assistant: # CurveProfilePoint(bpy_struct)

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

*class* bpy.types.CurveProfilePoint(*bpy_struct*)
:   Point of a path used to define a profile

    handle_type_1
    :   Path interpolation at this point

        Type:
        :   enum in [`'AUTO'`, `'VECTOR'`, `'FREE'`, `'ALIGN'`], default `'FREE'`

    handle_type_2
    :   Path interpolation at this point

        Type:
        :   enum in [`'AUTO'`, `'VECTOR'`, `'FREE'`, `'ALIGN'`], default `'FREE'`

    location
    :   X/Y coordinates of the path point

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

    select
    :   Selection state of the path point

        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: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Arc tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.xhtml#grease-pencil-draw-common-options) for more information.

### Creating Arcs

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can tweak the arc using a single cyan manipulator (hand icon).
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to make a perfect arc,
use `Alt` to create the arc from a center point or `M` to flip.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel`
will increase or decrease the amount of points in the final arc.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_arc_example-01.png   click and dragging the start point. | ../../../../_images/grease-pencil_modes_draw_tools_arc_example-02.png   Tweaking arc with the manipulator. | ../../../../_images/grease-pencil_modes_draw_tools_arc_example-03.png   The arc after confirming. |

### Extruding

Before confirming you can use `E` to extrude the end point of the arc
to generate multiple connected arcs.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-01.png   End point extruding. | ../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-02.png   Tweaking the last arc with the manipulator. | ../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-03.png   The connected arcs after confirming. |
user: Describe Render Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: # Render Settings

Device
:   Specifies the compute device used for rendering in Cycles.
    The choice of device can significantly affect render performance, *GPU Compute* is often faster .

    CPU:
    :   Render using the system’s central processing unit. This mode is compatible with all Cycles features.
        The number of CPU threads used can be changed in the
        [Performance Properties](performance.html).

    GPU Compute:
    :   Render using one or more graphics processing units (GPUs) through the compute backend
        and devices selected in the [Cycles Render Devices](../../../editors/preferences/system.html#editors-preferences-cycles).
        Depending on the backend, it may be possible to use both CPU and GPU devices simultaneously.

        For more details, including setup instructions, device compatibility, and known limitations,
        see [GPU Rendering](../gpu_rendering.html).

Open Shading Language
:   Enables the use of [Open Shading Language](../osl/index.html) which allows custom shading using shader scripts.
    When OSL is enabled, you can:

    - Use OSL shader nodes in materials using the [Script Node](../../shader_nodes/utilities/script.html).
    - Write custom shading logic that is not possible with built-in Cycles nodes.

    Limitations:

    - OSL is supported only when rendering with the *CPU* or with the
      [OptiX](../gpu_rendering.html#render-cycles-gpu-optix) GPU Compute backend.
    - Rendering performance is typically slower than with built-in nodes due to shader compilation and interpretation.
    - Some features, such as baking and certain volume shaders, may not work with OSL.
user: What is Property Subtype Number Items and how is it used in Blender Python scripting?

assistant: # Property Subtype Number Items

PIXEL:
:   Pixel.

    A distance on screen.

PIXEL_DIAMETER:
:   Pixel.

    A distance on screen, specifically representing a diameter value.

UNSIGNED:
:   Unsigned.

PERCENTAGE:
:   Percentage.

    A percentage between 0 and 100.

FACTOR:
:   Factor.

    A factor between 0.0 and 1.0.

ANGLE:
:   Angle.

    A rotational value specified in radians.

TIME:
:   Time (Scene Relative).

    Time specified in frames, converted to seconds based on scene frame rate.

TIME_ABSOLUTE:
:   Time (Absolute).

    Time specified in seconds, independent of the scene.

DISTANCE:
:   Distance.

    A distance between two points.

DISTANCE_DIAMETER:
:   Distance.

    A distance between two points, specifically representing a diameter value.

DISTANCE_CAMERA:
:   Camera Distance.

POWER:
:   Power.

TEMPERATURE:
:   Temperature.

WAVELENGTH:
:   Wavelength.

COLOR_TEMPERATURE:
:   Color Temperature.

FREQUENCY:
:   Frequency.

NONE:
:   None.
user: Give a detailed overview of Collection Line Art: syntax, arguments, return values, common patterns.

assistant: Sets up a [Line Art Modifier](modifiers/generate/line_art.html) for the active collection
by creating an “empty” Grease Pencil object with a Line Art modifier referencing each object in the collection.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Unsigned Angle
:   The shortest angle in radians between two faces where they meet at an edge.
    The range of the data is from zero to PI. Flat edges and [Non-manifold](../../../../glossary/index.xhtml#term-Non-manifold)
    edges have an angle of zero. An edge between two faces completely folded
    back on each other has an angle of PI, or 180 degrees.

Signed Angle
:   The signed angle in radians between two faces where they meet at an edge. Flat edges
    and Non-manifold edges have an angle of zero. Concave angles are positive and convex
    angles are negative.
user: Describe Toggle Cyclic from the Blender manual or Python API, including usage steps and snippets.

assistant: Toggles between an open curve and closed curve (Cyclic).
Only curves with at least one selected control point will be closed/open.
The shape of the closing segment is based on the start and end handles for Bézier curves,
and as usual on adjacent control points for NURBS.
The only time a handle is adjusted after closing is if the handle is an *Auto* one.
Fig. [Open and Closed curves.](#fig-curve-editing-open-close) is the same Bézier curve open and closed.

This action only works on the original starting control point or the last control point added.
Deleting a segment(s) does not change how the action applies;
it still operates only on the starting and last control points. This means that
`Alt`-`C` may actually join two curves instead of closing a single curve!
Remember that when a 2D curve is closed, it creates a renderable flat face.

[image reference removed]

Open and Closed curves.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field indicating which elements to scale.

Scale
:   The scaling factor for each element.

Center
:   The pivot point for each element.

Axis Single Axis Mode Only
:   Axis along which to scale each element. This vector is normalized internally, so the length does not matter.

Scale Mode
:   Uniform:
    :   Scale elements by the same factor in every direction.

    Single Axis:
    :   Scale elements in a single direction defined by the *Axis* input.
user: Explain Parent Inverse Transform in complete detail according to the official Blender documentation.

assistant: The *Parent Inverse* transform defines how the child object’s local space
is offset relative to its parent. It ensures that when parenting is created,
the child keeps its current world position, even though it now inherits
transforms from the parent.

The matrix is displayed decomposed into **Location**, **Rotation**, and **Scale** values.
These represent the offset needed to maintain the child’s position relative to its parent.
The values are read-only and shown for inspection only.

The *Rotation Mode* determines how the rotation component is displayed,
and can be switched between systems such as *XYZ Euler*, *Axis Angle*, or *Quaternion*.
This behaves identically to the [Rotation Mode](#bpy-types-object-rotation-mode) selector used in the main transform panel.

### Clear Parent Inverse Transform

Clears the *Parent Inverse* matrix from the selected objects. With an empty matrix,
the location, rotation, and scale properties of the children are interpreted
directly in the coordinate space of the parent.

This effectively makes the child’s transforms relative to the parent’s origin,
potentially moving the object in world space.

See [Clear Parent](../editing/parent.xhtml#bpy-ops-object-parent-clear) for additional methods to clear or manage parent-child relationships.
user: How do I use Overview in Blender? Include parameters, examples, warnings and best practices.

assistant: Closures are a socket type that represent callable node graphs.
They define a set of inputs and outputs that can be evaluated inside another node group through the
[Evaluate Closure](evaluate_closure.xhtml) node.

When a closure is connected, its internal node graph is *injected* into the evaluation of the node group where it is
used. This allows procedural systems to remain flexible while exposing clear, customizable control points.

Closures can be thought of as function parameters for node groups.
They let users define operations that can be executed in a controlled environment defined by the parent node tree.
user: Provide the full official documentation entry for Tool Settings, preserving all code examples.

assistant: ### Common

Color
:   Adjust the color of existing and new strokes.

Annotation Layer
:   A pop-over menu, showing the name of the current layer, to access the [Annotation Layers](#annotation-layers).

Placement
:   Determines where the annotations are drawn.

    3D Cursor:
    :   Only available in the 3D Viewport. The new annotations become part of the 3D scene;
        they’re drawn on an imaginary plane that goes through the [3D Cursor](../editors/3dview/3d_cursor.html)
        and is aligned to your view.

    Surface:
    :   Only available in the 3D Viewport. The new annotations become part of the 3D scene;
        they’re drawn onto the surface of the object under the mouse. If there is no surface,
        you get the same behavior as *3D Cursor*.

    Image:
    :   Only available in 2D editors such as the [Image Editor](../editors/image/introduction.html).
        The annotations become part of the 2D space, meaning their position and size change as you
        pan and zoom in the editor.

    View:
    :   The new annotations are 2D and get stuck to the screen. They keep the same position,
        rotation and size no matter how you pan, orbit or zoom in the editor.

Only End Points Surface Placement
:   Only use the first and last parts of the stroke for snapping.

Project Onto Selected Surface Placement
:   Only project the strokes onto selected objects.

Stabilize Stroke
:   Helps to reduce jitter of the strokes while drawing by delaying and correcting the location of points.

    Radius
    :   Minimum distance from the last point before the stroke continues.

    Factor
    :   A smooth factor, where higher values result in smoother strokes
        but the drawing sensation feels like as if you were pulling the stroke.

### Annotate Line

Style Start, End
:   The decoration to use at the beginning or end of the line segment.
    This can be used for example to create arrows to point out specific details in a scene.
user: Give a detailed overview of Overview: syntax, arguments, return values, common patterns.

assistant: This template streamlines the process of planning and sketching shots for animation or film
projects. Each shot is represented as its own scene, allowing independent Grease Pencil drawings,
camera settings, and timing, while the Sequencer serves as a master timeline to organize shots.
user: Give a detailed overview of One Time Setup: syntax, arguments, return values, common patterns.

assistant: This assumes you have the Blender manual repository already checked out on your computer, following the [install
instructions](install/index.xhtml).

### Fork

1. Go to Blender repository and click the Fork button.
2. Confirm the fork with the default settings.
3. Now you will have to add your personal fork as a remote in your local git repository.
   Click *SSH* to see the correct URL, and then add it like this:

   ```
   git remote add me git@git.blender.org:<USERNAME>/blender-manual.git
   ```
user: How do I use Switch Direction in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Switch Direction* operator reverses the direction of a selected curve.
The start point of the curve becomes the end point, and vice versa.
This operation does not change the visual appearance of the curve,
but affects its behavior when used as a path or with options like beveling and tapering.
user: Show practical ways to work with WorldMistSettings(bpy_struct) in a Blender add-on or script – include code.

assistant: # WorldMistSettings(bpy_struct)

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

*class* bpy.types.WorldMistSettings(*bpy_struct*)
:   Mist settings for a World data-block

    depth
    :   Distance over which the mist effect fades in

        Type:
        :   float in [0, inf], default 25.0

    falloff
    :   Type of transition used to fade mist

        - `QUADRATIC`
          Quadratic – Use quadratic progression.
        - `LINEAR`
          Linear – Use linear progression.
        - `INVERSE_QUADRATIC`
          Inverse Quadratic – Use inverse quadratic progression.

        Type:
        :   enum in [`'QUADRATIC'`, `'LINEAR'`, `'INVERSE_QUADRATIC'`], default `'QUADRATIC'`

    height
    :   Control how much mist density decreases with height

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

    intensity
    :   Overall minimum intensity of the mist effect

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

    start
    :   Starting distance of the mist, measured from the camera

        Type:
        :   float in [0, inf], default 5.0

    use_mist
    :   Occlude objects with the environment color as they are further away

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

assistant: # Introduction

The geometry of a scene is constructed from one or more objects.
These objects can range from lights to illuminate your scene, basic 2D and 3D shapes to fill it with models,
armatures to animate those models, to cameras to take pictures or make video of it all.

Each Blender [object type](types.xhtml) (mesh, light, curve, camera, etc.)
is composed from two parts: an *Object* and *Object Data* (sometimes abbreviated to “ObData”):

Object
:   Holds information about the position, rotation and size of a particular element.

Object Data
:   Holds everything else. For example:

    Meshes:
    :   Store geometry, material list, vertex groups, etc.

    Cameras:
    :   Store focal length, depth of field, sensor size, etc.

    Each object has a link to its associated [object-data](../../editors/properties_editor.xhtml#properties-data-tabs),
    and a single object-data may be shared by many objects.
user: Provide the full official documentation entry for Solidify Faces, preserving all code examples.

assistant: # Solidify Faces

This takes a selection of faces and solidifies them by extruding them
uniformly to give volume to a [Non-manifold](../../../../glossary/index.xhtml#term-Non-manifold) surface.
This is also available as a [Modifier](../../../modifiers/generate/solidify.xhtml).
After using the tool, you can set the offset distance in the [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Thickness
:   Amount to offset the newly created surface.
    Positive values offset the surface inward relative to the normals direction.
    Negative values offset outward.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_face_solidify-faces_before.png   Mesh before solidify operation. | ../../../../_images/modeling_meshes_editing_face_solidify-faces_after.png   Solidify with a positive thickness. | ../../../../_images/modeling_meshes_editing_face_solidify-faces_after2.png   Solidify with a negative thickness. |
user: Explain Cache Settings in complete detail according to the official Blender documentation.

assistant: This panel allows configuration of how and when image data is cached during editing.
These settings apply globally to all strips in the Video Sequence Editor.

Prefetch Frames
:   When enabled, Blender will automatically prefetch and cache frames after the current frame
    in the background. This can result in smoother playback performance.

    Note: prefetching is not currently supported for Scene strips.

Cache
:   Raw
    :   Caches raw image data immediately after it is read from disk.
        This speeds up adjustments to strip parameters such as color correction,
        but increases memory usage.

    Final
    :   Caches the final composited image for each frame,
        allowing faster playback of fully processed strips.

### Display

Visual indicators in the Timeline showing which frames are cached.

Cache
:   Raw
    :   Displays a red bar in the Timeline below frames cached in their raw state.

    Final
    :   Displays a blue bar at the top of Timeline for frames cached in their final composited state.

A readout at the bottom of the panel shows real-time statistics about cache usage:

- **Current Cache Size**: Total amount of memory currently used by the cache system.
- **Raw**: Memory usage by raw image cache.
- **Final**: Memory usage by final rendered frame cache.
user: Give a detailed overview of Simple Deform Modifier: syntax, arguments, return values, common patterns.

assistant: # Simple Deform Modifier

The *Simple Deform* modifier allows the application of a simple deformation to
an object. Meshes, lattices, curves, surfaces and texts are supported objects.
The deformation is either a rotation (Twist, Bend) or a scaling (Taper, Stretch).
The amount of deformation is specified by the Deform Angle (rotation) or Deform Factor (scaling).

[image reference removed]

The Simple Deform modifier.

The deformation is calculated in the *local* coordinate space.
Be aware that the local axes of an object can differ from the global ones.
In the figure above, the global Z axis points up and the local Z axis points at 45°.
The deformation is applied along a Deform axis, which can be set by selection from a list (X, Y or Z).
By using the *Limits* field, the influence of the modifier can be restricted to a subset of the Deform axis.
All distances are measured from the origin of the object.
The vertices that are furthest away from the origin on the Deform axis
represent the upper and lower limits.
The origin of the object and the orientation of the local axes
can be defined by an external Deform object (most of the time, an empty).
user: What is Geometry Node and how is it used in Blender Python scripting?

assistant: # Geometry Node

[image reference removed]

The *Geometry* node gives geometric information about the current shading point.
All vector coordinates are in *World Space*. For volume shaders,
only the position and incoming vector are available.
user: Explain Lights in complete detail according to the official Blender documentation.

assistant: Light Tree
:   Use a light tree to more effectively sample lights in the scene, taking into account
    distance and estimated intensity.
    This can significantly reduce noise, at the cost of a somewhat longer render time per sample.

    Certain lighting properties are not accounted for in the light tree. This includes custom
    falloff, ray visibility, and complex shader node setups including textures.
    This can result in an increase in noise in some scenes that make use of these features.

Light Threshold
:   Probabilistically terminates light samples when the light contribution is below the threshold.
    This avoids wasting time on lights that contribute little to the image.
    Zero disables the test.
user: Describe Track Motion from the Blender manual or Python API, including usage steps and snippets.

assistant: The Track Motion menu is used to perform tracking of selected tracks
(i.e. following the selected feature from frame to frame).

This operator depends on settings from the Tracking Settings panel.
If during sequence tracking the algorithm fails to track some markers,
they will be disabled and tracking will continue for the rest of the markers.
If the algorithm fails when tracking frame-by-frame, the marker is not disabled,
and the most likely position of the feature on the next frame is used.

### Backwards

Tracks the motion backward along the sequence.

### Frame Backwards

Tracks the motion backward by one frame.

### Forwards

Tracks the motion forward along the whole sequence.

### Frame Forwards

Tracks the motion forward one frame.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Type
:   Specifies the input/output type.

    Vector, Point, Normal.

Convert From
:   Coordinate Space to convert from:

    World, Object, Camera.

Convert To
:   Coordinate Space to convert to:

    World, Object, Camera.