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

assistant: Material:
:   Create a new material with the Stroke Base Color to be the sampled color.

    Material Mode
    :   The color transformation will be applied on the stroke and/or the fill color.

        Stroke:
        :   Only paint over strokes.

        Fill:
        :   Only paint over fill areas.

        Both:
        :   Paint over strokes and fill areas

Palette:
:   Add a new color to the color palette based on the sampled color.

Brush:
:   Sets the brush color to the sampled color.
user: Describe Curve Guide from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve Guide

The *Curve Guide* is used to force particles to follow a certain
path defined by a [Curve Object](../../../../modeling/curves/index.html).
A typical scenario would be to move a red blood cell inside a vein,
or to animate the particle flow in a motor.
You can also use *Curve Guide* to shape certain hair strands.

Since you can animate curves as a soft body or any other usual way,
you may build very complex animations while keeping great control and keeping the simulation time to a minimum.

To make particles point in the direction of the curve, you need to set their *Orientation Axis*
to *Velocity / Hair*, enable *Dynamic*, and set their *Angular Velocity Axis* to *Velocity*,
all in the [Rotation](../../../particles/emitter/rotation.html) settings of the particle system.
The [Follow Path Constraint](../../../../animation/constraints/relationship/follow_path.html) and the curve’s legacy
[Follow](../../../../modeling/curves/properties/path_animation.html#bpy-types-curve-use-path-follow) option won’t work for this.

A *Curve Guide* force affects all particles on the same layer, independently from their distance to the curve.
If you have several guides in a layer,
their fields add up to each other (the way you may have learned it in your physics course).
But you can limit their influence radius by changing the *Minimum Distance* (see below).

A particle follows a *Curve Guide* during its lifetime,
the velocity depends on its lifetime and the length of the path.
user: What is ImageUser(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ImageUser(bpy_struct)

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

*class* bpy.types.ImageUser(*bpy_struct*)
:   Parameters defining how an Image data-block is used by another data-block

    frame_current
    :   Current frame number in image sequence or movie

        Type:
        :   int in [-1048574, 1048574], default 0

    frame_duration
    :   Number of images of a movie to use

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

    frame_offset
    :   Offset the number of the frame to use in the animation

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

    frame_start
    :   Global starting frame of the movie/sequence, assuming first picture has a #1

        Type:
        :   int in [-1048574, 1048574], default 0

    multilayer_layer
    :   Layer in multilayer image

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

    multilayer_pass
    :   Pass in multilayer image

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

    multilayer_view
    :   View in multilayer image

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

    tile
    :   Tile in tiled image

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

    use_auto_refresh
    :   Always refresh image on frame changes

        Type:
        :   boolean, default False

    use_cyclic
    :   Cycle the images in the movie

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Avoid Problematic Footage and how is it used in Blender Python scripting?

assistant: The 2D stabilizer can not work miracles; some flaws simply can not be fixed satisfactory.
Notorious issues are motion blur, rolling shutter, pumping autofocus and moving compression artifacts.
Especially if you do succeed with basic stabilization, such image flaws become yet the more noticeable and annoying.
When on set or on location, it might be tempting to “fix matters in post production”.
Resist that deception, it rarely works out well.

- Prefer a short exposure time to avoid motion blur.
  While motion blur is good to render filmed movements more smooth and natural,
  it seriously impedes the ability to track features precisely.
  As a guideline, try to get at least to 1/250 s.
- Prefer higher frame rates. The more *temporal resolution* the stabilizer has to work on, the better the results.
  If you have the option to choose between progressive and interlaced modes, by all means use interlaced
  and deinterlace the footage to the *doubled frame rate*. This can be done with
  the [yadif](https://ffmpeg.org/ffmpeg-filters.html#yadif-1) filter of FFmpeg: use the mode 1 (`send_field`).
- Beware of the [Rolling Shutter](../../../../../glossary/index.xhtml#term-Rolling-Shutter) effect. Avoid fast lateral movements.
  If you can, prefer a camera which produces less rolling shutter.
  Also, using a higher frame rate reduces the amount of rolling shutter; another reason to prefer
  interlaced over progressive for the purpose at hand.
- Switch off autofocus.
  Better plan your movement beforehand, set a fixed focus and rely on depth of field through using a small aperture.
  Pumping movements might not be so noticeable to the human observer, but the feature tracking tends to slide away
  on defocused image elements; fixing this manually after the fact can cause a huge waste of time.
- Increase the lighting level, at least use a higher sensitivity.
  This helps to set a fast shutter speed plus a small aperture.
  Better lighting and good exposure also help to reduce the impact of compression artifacts.
  If you can, also select a codec with less data reduction, better color space, etc.
  Inevitably, we’re loosing some quality through the interpolation necessary for stabilization.
  Plus we’re loosing some quality due to color space conversion.
user: How do I use Toggle Cyclic in Blender? Include parameters, examples, warnings and best practices.

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

assistant: # Rotate Instances Node

[image reference removed]

The *Rotate Instances* node rotates geometry instances in local or global space.

The [Instances](../instances.html) page contains more information about geometry instances.
user: Describe Bone Collections from the Blender manual or Python API, including usage steps and snippets.

assistant: This list shows the [bone collections](../../../../glossary/index.xhtml#term-Bone-Collection) the bone is assigned to.
Press the eye icon to show or hide the entire bone collection.
Press the star icon to show only this bone collection, and others also marked as ‘solo’
Press the X icon to remove the bone from that particular collection.

To assign the bone to other bone collections, either use the `M` or `Shift`-`M` shortcuts
(see [Moving Bones Between Collections](../../properties/bone_collections.xhtml#moving-bones-between-collections))
or go to the [Armature properties panel](../../properties/bone_collections.xhtml#bpy-types-bonecollection).
user: Describe GeometryNodeGizmoTransform(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeGizmoTransform(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.GeometryNodeGizmoTransform(*GeometryNode*)
:   Show a transform gizmo in the viewport

    use_rotation_x
    :   Type:
        :   boolean, default False

    use_rotation_y
    :   Type:
        :   boolean, default False

    use_rotation_z
    :   Type:
        :   boolean, default False

    use_scale_x
    :   Type:
        :   boolean, default False

    use_scale_y
    :   Type:
        :   boolean, default False

    use_scale_z
    :   Type:
        :   boolean, default False

    use_translation_x
    :   Type:
        :   boolean, default False

    use_translation_y
    :   Type:
        :   boolean, default False

    use_translation_z
    :   Type:
        :   boolean, default False

    *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: Show practical ways to work with NodeTreeInterfacePanel(NodeTreeInterfaceItem) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfacePanel(NodeTreeInterfaceItem)

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

*class* bpy.types.NodeTreeInterfacePanel(*NodeTreeInterfaceItem*)
:   Declaration of a node panel

    default_closed
    :   Panel is closed by default on new nodes

        Type:
        :   boolean, default False

    description
    :   Panel description

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

    interface_items
    :   Items in the node panel

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

    name
    :   Panel name

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

    persistent_uid
    :   Unique identifier for this panel within this node tree

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ip.use_flip_x SceneStrip.use_flip_y SceneStrip.use_float SceneStrip.use_proxy SceneStrip.use_reverse_frames SceneStrip.volume SceneStrip.bl_rna_get_subclass() SceneStrip.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: How do I use Property Subtype String Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Property Subtype String Items

FILE_PATH:
:   File Path.

DIR_PATH:
:   Directory Path.

FILE_NAME:
:   File Name.

BYTE_STRING:
:   Byte String.

PASSWORD:
:   Password.

    A string that is displayed hidden (’\*\*\*\*\*\*\*\*’).

NONE:
:   None.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Sun Beams

Usually, the first step is to define the area from which rays are cast.
Any diffuse reflected light from surfaces is not going to contribute to such scattering in the real world,
so should be excluded from the input data.
Possible ways to achieve this are:

- Entirely separate image as a light source.
- Brightness/contrast tweaking to leave only the brightest areas.
- Muting shadow and midtone colors, which is a bit more flexible.
- Masking for ultimate control.

After generating the sun beams from such a light source image they can then be overlaid on the original image.
Usually, a simple “Add” Mix node is sufficient,
and physically correct because the scattered light adds to the final result.

[image reference removed]
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Pixelate Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_pixelate_size-0.png   Original image. | ../../_images/grease-pencil_visual-effects_pixelate_size-20.png   Size: 20 px. | ../../_images/grease-pencil_visual-effects_pixelate_size-100.png   Size: 100 px. | ../../_images/grease-pencil_visual-effects_pixelate_size-200.png   Size: 200 px. |
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: Below are some examples illustrating edge subdivision in various scenarios.

[image reference removed]

The sample mesh.

### One Edge

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_one-edge.png   One edge. | ../../../../_images/modeling_meshes_editing_edge_subdivide_one-edge-tri.png   *Create N-Gons* unchecked. |

### Two Tri Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-tri.png   Two tri edges. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-tri-tri.png   *Create N-Gons* unchecked. |

### Two Opposite Quad Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-opposite.png   Two quad edges. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-opposite-tri.png   *Create N-Gons* unchecked. |

### Two Adjacent Quad Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-innervert.png   Inner Vertices corner type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-innervert-tri.png   *Create N-Gons* unchecked. |

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-path.png   Path corner type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-path-tri.png   *Create N-Gons* unchecked. |

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-straight_cut.png   Straight Cut corner type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-innervert-tri.png   *Create N-Gons* unchecked. |

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-fan2.png   Fan cut type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-fan.png   *Create N-Gons* unchecked. |

### Three Quad Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges.png   Three edges. | ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges-tri.png   *Create N-Gons* unchecked. |

### Full Triangle

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges-tri2.png   Full triangle. | ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges-tri-tri.png   *Create N-Gons* unchecked. |

### Full Quad

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_four-edges.png   Full quad. | ../../../../_images/modeling_meshes_editing_edge_subdivide_four-edges-tri.png   *Create N-Gons* unchecked. |

### Multiple Cuts

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_tri-multi.png   Triangle with two cuts. | ../../../../_images/modeling_meshes_editing_edge_subdivide_quad-multi.png   Quad with two cuts. |
user: Explain Property Override Flag Collection Items in complete detail according to the official Blender documentation.

assistant: # Property Override Flag Collection Items

LIBRARY_OVERRIDABLE:
:   Library Overridable.

    Make that property editable in library overrides of linked data-blocks.
    NOTE: For a property to be overridable, its whole chain of parent properties must also be defined as overridable.

NO_PROPERTY_NAME:
:   No Name.

    Do not use the names of the items, only their indices in the collection.

USE_INSERTION:
:   Use Insertion.

    Allow users to add new items in that collection in library overrides.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

UI for a Fluid Flow force field.

Domain Object
:   An object that is used as a domain for the smoke simulation.

Apply Density
:   Adjust the force strength based on the smoke density.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

[Constraints](../../../glossary/index.xhtml#term-Constraint) (also known as joints) for rigid bodies connect two rigid bodies.
The physics constraints are meant to be attached to an [Empty](../../../glossary/index.xhtml#term-Empty) object.
The constraint then has fields which can be pointed at the two physics-enabled object
which will be bound by the constraint.
The empty object provides a location and axis for the constraint distinct from the two constrained objects.
The location of the entity hosting the physics constraint marks a location and
set of axes on each of the two constrained objects.
These two anchor points are calculated at the beginning of the animation and their position and
orientation remain fixed in the *local* coordinate system of the object for the duration of the animation.
The objects can move far from the constraint object, but the constraint anchor moves with the object.
If this feature seems limiting, consider using multiple objects with a non-physics *Child of* constraint and
animate the relative location of the child.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Surface
:   The appearance of the environment.
    Usually connected to a [Background](../shader/background.xhtml) shader.

Volume
:   Used to add volumetric effects to the world.
    See the shaders [Principled Volume](../shader/volume_principled.xhtml),
    [Volume Absorption](../shader/volume_absorption.xhtml),
    and [Volume Scatter](../shader/volume_scatter.xhtml) for more information.
user: What is Set Handle Type Node and how is it used in Blender Python scripting?

assistant: # Set Handle Type Node

[image reference removed]

Sets the handle type for the points on the Bézier curve that are in the selection.

A selection for a certain handle type can be retrieved with
the [Handle Type Selection Node](../read/handle_type_selection.html).
user: Explain Editing in complete detail according to the official Blender documentation.

assistant: ### Duplicate Marker

You can duplicate the selected markers by pressing `Shift`-`D`. Once duplicated,
the new ones are automatically placed in select mode, so you can move them to the desired location.

### Duplicate Marker to Scene

Duplicates the selected markers into another scene.

### Delete Marker

To delete the selected markers simply press `X`,
and confirm the pop-up message with `LMB`.

### Rename Marker

Having dozens of markers scattered throughout your scene’s time will not help you much unless you
know what they stand for. You can name a marker by selecting it, pressing `F2`,
typing the name, and press `Return`

### Move Marker

Once you have one or more markers selected, press `G`,
while hovering with the mouse over the marker bar,
to move them, and confirm the move with `LMB` or `Return`
(as usual, cancel the move with `RMB`, or `Esc`).
Or drag them with the `LMB`.

By default, you move the markers in one-frame steps, but if you hold `Ctrl`,
the markers will move in steps corresponding to 1 second (according to the scene’s *FPS*).

### Select

Convenient operators for selecting Marks; see [Selecting](#bpy-ops-marker-select) for more information on selecting Markers.

All `A`
:   Selects all Markers.

None `Ctrl`-`A`
:   Deselects any already selected Markers.

Invert `Ctrl`-`I`
:   Select all unselected Markers and deselects all selected Markers.

Before Current Frame
:   Selects all Markers to the left of the current frame and the Marker on the current frame if it exists.

After Current Frame
:   Selects all Markers to the Right of the current frame and the Marker on the current frame if it exists.

### Show Pose Markers

Shows markers belonging to the active action instead of scene markers.

### Make Markers Local

It is possible to convert standard markers into pose markers with Marker ‣ Make Markers Local.
Note that the original marker will be gone. If you want to keep it, make a duplicate before you convert.

### Jump to Next/Previous Marker

Moves the Playhead to the next/previous marker relative to the current frame.
user: Give a detailed overview of Select Menus: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The 3D Viewport Mode Select menu.

A *Select Menu* (or “selector”) allows you to choose from a predefined list of options.
It appears as a text label and/or icon with a down arrow on the right.

Click with `LMB` to open the menu and choose an option.
The selected option will then appear inside the button.
You can also cycle through options without opening the menu
by scrolling on top of the button with `Ctrl`-`Wheel`.

### Expanded View

[image reference removed]

Expanded menu view.

Some select menus use an expanded layout to show all available options at once.
In this view, the active option is highlighted with a colored background.

In certain cases, you can select multiple options by holding `Shift` and clicking with `LMB`.
user: Show practical ways to work with Panels in a Blender add-on or script – include code.

assistant: [image reference removed]

Panels in Properties.

A panel is highlighted in yellow and a subpanel in red.

The smallest organizational unit in the user interface is a panel.
The panel header shows the title of the panel. It is always visible.
Some panels also include subpanels.

### Collapsing and Expanding

A panel can either be expanded to show its contents, or collapsed to hide its contents.
An expanded panel is indicated by a down-arrow (▼) in the panel header,
while a collapsed panel is shown with a right-arrow (►).

- Clicking `LMB` on the panel header expands or collapses it.
- Pressing `A` expands/collapses the panel under the mouse pointer.
- Clicking `Ctrl`-`LMB` on the header of a collapsed panel will expand it and collapse all others.
- Clicking `Ctrl`-`LMB` on the header of an expanded panel will expand/collapse all its subpanels.
- Dragging with `LMB` over the headers will expand or collapse many at once.

### Position

You can change the position of a panel within its region by clicking
and dragging the grip widget (::::) on the right side of its header.

### Pinning

Sometimes it is desirable to view panels from different tabs at the same time.
Like, for instance, having access to a camera’s properties, while other objects are selected.
This has been solved by making panels pinnable.

A pinned panel remains visible regardless of which tab has been selected.
You can pin a panel by clicking on the pin icon in its header.
Panels that do not have a pin icon can be pinned by `RMB` on the panel header
and selecting *Pin*, or by pressing `Shift`-`LMB`.

### Presets

Panels in Blender provide a **Presets** menu () for quickly reusing common settings.
Presets can save time by storing frequently used configurations, which can then be reapplied with a single click.

[image reference removed]

Example Presets menu.

Selector
:   A list of available presets. Selecting one will apply the stored values to the relevant properties.

    Preset Name
    :   The name to use when adding a new preset.

    (Add)
    :   Create a new preset using the current settings,
        the preset is then saved and appears in the list for future reuse.

    (Remove)
    :   Deletes the selected preset.

Presets are stored as Python files in Blender’s [configuration directory](../../advanced/blender_directory_layout.xhtml#blender-directory-path-layout).
Advanced users can edit these preset files directly to fine-tune settings or copy them to other systems.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Data Type
:   Map Range supports both Float and Vector data types. Changing the data type will
    also update the sockets to reflect the data type chosen.

Interpolation Type
:   The mathematical method used to transition between gaps in the numerical inputs.

    Linear:
    :   Linear interpolation between From Min and From Max values.

    Stepped Linear:
    :   Stepped linear interpolation between From Min and From Max values.

    Smooth Step:
    :   Smooth Hermite edge interpolation between From Min and From Max values.

    Smoother Step:
    :   Smoother Hermite edge interpolation between From Min and From Max values.

Clamp
:   If enabled, the output is clamped to the target range.
user: Describe Remove Named Attribute Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Remove Named Attribute Node

[image reference removed]

The *Remove Named Attribute* node deletes an attribute with a certain name from its geometry input.
Any attribute that exists on geometry data will be automatically propagated when the geometry storing it
is changed, which can be an expensive operation, so using this node can be a simple way to optimize
the performance of a geometry node tree or even to lower the memory usage of the entire scene.

Almost all named attributes can be removed. For certain [Built-In Attributes](../attributes_reference.xhtml#geometry-nodes-builtin-attributes),
removing it will mean that a default value will be used instead. For example, removing the
[cyclic](../curve/read/is_spline_cyclic.xhtml) attribute on curves means that
all curves will be non-cyclic.
user: Provide the full official documentation entry for Basic Usage, preserving all code examples.

assistant: In this example we will use a UV sphere with an extruded “north pole” as our base object and
a cube as our parent mesh. To parent the sphere to the cube, in *Object Mode*,
first `LMB` select the sphere, then `Shift`-`LMB` select the cube
(order is very important here), and finally `Ctrl`-`P` to parent.

|  |  |
| --- | --- |
| ../../../../_images/scene-layout_object_properties_instancing_faces_cube-before.png   A cube and a sphere. | ../../../../_images/scene-layout_object_properties_instancing_faces_cube-after.png   Instancing Faces applied to the cube. |

Next, in the Properties ‣ Object Properties ‣ Instancing,
select *Faces*. The sphere is instanced, one for each face of the cube.

Both the parent object and original are displayed as editable “templates” in 3D Viewport,
but neither is rendered.
user: Provide the full official documentation entry for BlendDataMaterials(bpy_struct), preserving all code examples.

assistant: # BlendDataMaterials(bpy_struct)

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

*class* bpy.types.BlendDataMaterials(*bpy_struct*)
:   Collection of materials

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

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

        Returns:
        :   New material data-block

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

    create_gpencil_data(*material*)
    :   Add Grease Pencil material settings

        Parameters:
        :   **material** ([`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material"), (never None)) – Material

    remove_gpencil_data(*material*)
    :   Remove Grease Pencil material settings

        Parameters:
        :   **material** ([`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material"), (never None)) – Material

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

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

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

assistant: Type
:   Strip type, represented by an icon.

Name
:   A text field to adjust the name of the strip, which is shown on the strip in the timeline.

    Color Tag
    :   Strips are given a [Default Color](../../../../video_editing/edit/montage/strips/introduction.html#sequencer-strip-colors) based on their type;
        using the color tag, you can assign a custom color to help organize your sequence.

Mute
:   Uncheck to prevent the strip from producing output.
user: Show practical ways to work with Set Attribute in a Blender add-on or script – include code.

assistant: Opens a pop-up window showing the name of the [active](../../glossary/index.xhtml#term-Active) [attribute](../../glossary/index.xhtml#term-Attribute)
as well as the value of that attribute for the selected points
From there, you assign a new value to a selected attribute across all selected points.

This tool is useful for uniformly setting attribute values such as size, color, or velocity across selected points.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   Geometry whose elements are iterated over.

Selection
:   Which subset of the chosen *Domain* to process.

Index
:   Index of the element in the source geometry. Note that the same index can occur more than
    once when iterating over multiple geometry component types at once.

Element
:   The input geometry is split up into a separate geometry for each element.
    This is the single element geometry for the current iteration. This is not available
    for the *Face Corner* domain, since face corners cannot exist without their face.
user: How do I use Header in Blender? Include parameters, examples, warnings and best practices.

assistant: Add New Layer
:   Adds a layer.

Remove Layer
:   Removes the active layer.

Move Layer
:   Moves the active layer down/up.

Isolate Layers (screen icon)
:   Toggle whether the active layer is the only one that can be edited and is visible.

Isolate Layers (padlock icon)
:   Toggle whether the active layer is the only one that can be edited.

### Insert Keyframe

You can press `I` while hovering over the Dope Sheet Editor to insert a keyframe.
It’ll create a copy of the active frame if
[Additive Drawing](../../../grease_pencil/modes/draw/introduction.xhtml#bpy-types-toolsettings-use-gpencil-draw-onback) is enabled,
and a blank frame otherwise.

### Copying Frames

It is possible to copy frames from one layer to another,
or from object to object, using the *Copy* and *Paste* tools in the *Key* menu.
Note that keyframes will be pasted into selected layers, so make sure you have a destination layer selected.
user: Explain LineStyleColorModifier_CreaseAngle(LineStyleColorModifier) in complete detail according to the official Blender documentation.

assistant: # LineStyleColorModifier_CreaseAngle(LineStyleColorModifier)

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

*class* bpy.types.LineStyleColorModifier_CreaseAngle(*LineStyleColorModifier*)
:   Change line color based on the underlying crease angle

    angle_max
    :   Maximum angle to modify thickness

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

    angle_min
    :   Minimum angle to modify thickness

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

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

        Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    color_ramp
    :   Color ramp used to change line color

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleColorModifier_CreaseAngle.type "bpy.types.LineStyleColorModifier_CreaseAngle.type")
user: Show practical ways to work with Importing in a Blender add-on or script – include code.

assistant: Import geometry and curves to the OBJ format.

If there is a matching `.MTL` for the OBJ then its materials will be imported too.

### General

Scale
:   Value by which to scale the imported objects in relation to the world’s origin.

Clamp Bounding Box
:   OBJ-files often vary greatly in scale, this setting clamps the imported file to a fixed size.

Forward Axis, Up Axis
:   Since many applications use a different axis for ‘Up’, these are axis conversion for these settings,
    Forward and Up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y Forward, Z Up (since the front view looks along the +Y direction).
    For example, it’s common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed.

### Options

Split By Object
:   Import each OBJ “object name” group (`o`) as a separate object.

Split By Group
:   Import each OBJ “object name” group (`g`) as a separate object.

Vertex Groups
:   Import OBJ groups as vertex groups.

Validate Meshes
:   Check the imported mesh for corrupt data and fix it if necessary.
    When disabled, erroneous data may cause crashes displaying or editing the meshes.
    This option will make the importing slower but is recommended, as data errors are not always obvious.

Detect Cyclic Curves
:   Joins curve endpoints if overlapping control points are detected (if disabled, no curves will be cyclic).

Path Separator
:   Character used to separate an object’s name into a hierarchical
    structure using [Collections](../../scene_layout/collections/index.xhtml).

### Materials

Material Name Collision
:   Behavior when the name of an imported material conflicts with an existing material.

    Make Unique:
    :   Import each USD material as a unique Blender material.

    Reference Existing:
    :   If a material with the same name already exists, reference that instead of importing.
user: What is Extra and how is it used in Blender Python scripting?

assistant: Parents Particles
:   Render also parent particles if child particles are used.
    Children have a lot of different deformation options,
    so the straight parents would stand between their curly children.
    So by default *Parents* are not rendered if you activate *Children*.
    See [Children](children.xhtml).

Unborn
:   Render particles before they are born.

Dead
:   Render particles after they have died.
    This is very useful if particles die in a collision *Die on hit*, so you can cover objects with particles.
user: What is Join and how is it used in Blender Python scripting?

assistant: # Join

Join merges all selected objects into the last selected *Active* object.
All object data is linked to the active object (which must be selected).
All objects must be of the same type: mesh, curve, surface or armature.
If several curves are joined, each one will keep its subtype (NURBS or Bézier).
user: Provide the full official documentation entry for Collisions, preserving all code examples.

assistant: # Collisions

[image reference removed]

Rigid Body Collisions panel.

Shape
:   Determines the collision shape of the object;
    these can be broken into two categories: primitive shapes and mesh based shapes.

    Primitive shapes (*Box*, *Sphere*, *Capsule*, *Cylinder*, and *Cone*)
    are best in terms of memory and performance but do not
    necessarily reflect the actual shape of the object.
    The size of the shape is calculated based on the object’s bounding box.
    The center of gravity is always in the geometric center of the shape.
    Primitive shapes can be shown in the 3D Viewport by enabling
    [Extras Overlay](../../../editors/3dview/display/overlays.html#bpy-types-view3doverlay-show-extras).

    Mesh based shapes (*Convex Hull* and *Mesh*) are calculated based on the geometry of the object
    so they are a better representation of the object.
    The center of gravity for these shapes is the object origin.

    Box:
    :   Box-like shapes (e.g. cubes), including planes (e.g. ground planes).
        The size per axis is calculated from the bounding box.

    Sphere:
    :   Sphere-like shapes. The radius is the largest axis of the bounding box.

    Capsule:
    :   This points up the Z axis.

    Cylinder:
    :   This points up the Z axis.
        The height is taken from the Z axis, while the radius is the larger of the X or Y axes.

    Cone:
    :   This points up the Z axis.
        The height is taken from the Z axis, while the radius is the larger of the X or Y axes.

    Convex Hull:
    :   A mesh-like surface encompassing (e.g. shrink-wrapped over) all vertices (best results with fewer vertices).
        A convex approximation of the object, which has good performance and stability.

    Mesh:
    :   [Mesh](../../../glossary/index.html#term-Mesh) consisting of triangles only, allowing for more detailed interactions than convex hulls.
        Allows simulating concave objects, but is rather slow and unstable.

    Compound Parent:
    :   Takes the collision shapes from the object’s [children](../../../scene_layout/object/editing/parent.html)
        and combines them. This makes it possible to create concave shapes from primitive shapes.
        This usually results in a faster simulation than the *Mesh* collision shape
        while also being generally more stable.

Source
:   Source of the mesh used to create the collision shape.

    Base:
    :   The base mesh of the object.

    Deform:
    :   Includes any deformations added to the mesh (shape keys, deform modifiers).

    Final:
    :   Includes all deformations and modifiers.

Deforming
:   Mesh shapes can deform during simulation.
user: Describe Emission from the Blender manual or Python API, including usage steps and snippets.

assistant: # Emission

[image reference removed]

The *Emission* node is used to add Lambertian emission shader.
This can for example, be used for material and light surface outputs.

Light strength for point, spot and area lights is specified in Watts.

Sun lights are specified in Watts/m2, which require much smaller values like 1 W/m2.
This can be confusing, but specifying strength in Watts would not have been convenient;
the real sun for example has strength 384.6×1024W.
Emission shaders on meshes are also in Watts/m2.
user: How do I use Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Rigid Body World
:   Enable/disable evaluation of the rigid body simulation based on the rigid body objects
    participating in the specified group of Rigid Body World.

Remove Rigid Body World
:   Remove rigid body simulation from the current scene.

Collection
:   Containing rigid body objects participating in this simulation.

Constraints
:   Containing rigid body object constraints participating in the simulation.

Simulation quality and timing settings:

Speed
:   Can be used to speed up/slow down the simulation.

Split Impulse
:   Enable/disable reducing extra velocity that can build up when objects collide
    (lowers the simulation stability a little so use only when necessary).
    Limits the force with which objects are separated on collision, generally produces nicer
    results, but makes the simulation less stable (especially when stacking many objects).

Substeps Per Frame
:   Number of simulation steps taken per frame (higher values are more accurate but slower).
    This only influences the accuracy and not the speed of the simulation.

Solver Iterations
:   Amount of constraint solver iterations made per simulation step (higher values are more accurate but slower).
    Increasing this makes constraints and object stacking more stable.
user: Provide the full official documentation entry for Bpy.Types.Greasepencilopacitymodifier, preserving all code examples.

assistant: easePencilOpacityModifier.use_layer_pass_filter GreasePencilOpacityModifier.use_material_pass_filter GreasePencilOpacityModifier.use_uniform_opacity GreasePencilOpacityModifier.use_weight_as_factor GreasePencilOpacityModifier.vertex_group_name GreasePencilOpacityModifier.bl_rna_get_subclass() GreasePencilOpacityModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Give a detailed overview of Custom-Data Layer Types: syntax, arguments, return values, common patterns.

assistant: *class* bmesh.types.BMLoopUV
:   pin_uv
    :   UV pin state.

        Type:
        :   bool

    uv
    :   Loops UV (as a 2D Vector).

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")

*class* bmesh.types.BMDeformVert
:   clear()
    :   Clears all weights.

    get(*key*, *default=None*)
    :   Returns the deform weight matching the key or default
        when not found (matches Python’s dictionary function of the same name).

        Parameters:
        :   - **key** (*int*) – The key associated with deform weight.
            - **default** (*Any*) – Optional argument for the value to return if
              *key* is not found.

    items()
    :   Return (group, weight) pairs for this vertex
        (matching Python’s dict.items() functionality).

        Returns:
        :   (key, value) pairs for each deform weight of this vertex.

        Return type:
        :   list[tuple[int, float]]

    keys()
    :   Return the group indices used by this vertex
        (matching Python’s dict.keys() functionality).

        Returns:
        :   the deform group this vertex uses

        Return type:
        :   list[int]

    values()
    :   Return the weights of the deform vertex
        (matching Python’s dict.values() functionality).

        Returns:
        :   The weights that influence this vertex

        Return type:
        :   list[float]
user: How do I use Instance on Elements Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Instance on Elements Node

[image reference removed]

The *Instance on Elements* node creates instances of an object, collection, or geometry
on selected elements of an input geometry.
It can be used to distribute instances on points, edges, faces, or face corners,
providing flexibility for procedural instancing workflows.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Normal Direction
:   To manually set a fixed normal direction vector.
    `LMB` click and drag on the sphere to set the direction of the normal.
    Holding `Ctrl` while dragging snaps to 45 degree rotation increments.