PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ShaderFx.name`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.name "bpy.types.ShaderFx.name") - [`ShaderFx.type`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.type "bpy.types.ShaderFx.type") - [`ShaderFx.show_viewport`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_viewport "bpy.types.ShaderFx.show_viewport") | - [`ShaderFx.show_render`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_render "bpy.types.ShaderFx.show_render") - [`ShaderFx.show_in_editmode`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_in_editmode "bpy.types.ShaderFx.show_in_editmode") - [`ShaderFx.show_expanded`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_expanded "bpy.types.ShaderFx.show_expanded") |
user: What is Subdivide and how is it used in Blender Python scripting?

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

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

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

Number of Cuts
:   The number of control points to add in each segment.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_knife-project_text-before.jpg   Before projecting from a text object. | ../../../../_images/modeling_meshes_editing_mesh_knife-project_text-after.jpg   Resulting knife projection. |
| ../../../../_images/modeling_meshes_editing_mesh_knife-project_mesh-before.jpg   Before projecting from a mesh object. | ../../../../_images/modeling_meshes_editing_mesh_knife-project_mesh-after.jpg   Resulting knife projection (extruded after). |
| ../../../../_images/modeling_meshes_editing_mesh_knife-project_curve-before.png   Before projecting from a 3D curve object. | ../../../../_images/modeling_meshes_editing_mesh_knife-project_curve-after.jpg   Resulting knife projection (extruded after). |
user: How do I use ParticleBrush(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ParticleBrush(bpy_struct)

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

*class* bpy.types.ParticleBrush(*bpy_struct*)
:   Particle editing brush

    count
    :   Particle count

        Type:
        :   int in [1, 1000], default 10

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

    length_mode
    :   - `GROW`
          Grow – Make hairs longer.
        - `SHRINK`
          Shrink – Make hairs shorter.

        Type:
        :   enum in [`'GROW'`, `'SHRINK'`], default `'GROW'`

    puff_mode
    :   - `ADD`
          Add – Make hairs more puffy.
        - `SUB`
          Sub – Make hairs less puffy.

        Type:
        :   enum in [`'ADD'`, `'SUB'`], default `'ADD'`

    size
    :   Radius of the brush in pixels

        Type:
        :   int in [1, 32767], default 50

    steps
    :   Brush steps

        Type:
        :   int in [1, 32767], default 10

    strength
    :   Brush strength

        Type:
        :   float in [0.001, 1], default 0.5

    use_puff_volume
    :   Apply puff to unselected end-points (helps maintain hair volume when puffing root)

        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: How do I use Quick Start in Blender? Include parameters, examples, warnings and best practices.

assistant: Open a terminal, then go to the directory where Blender is installed,
and run Blender like this:

```
cd <blender installation directory>
./blender
```

If you have Blender installed in your `PATH`
(usually when Blender is installed through a distribution package), you can simply run:

```
blender
```
user: Describe Import from the Blender manual or Python API, including usage steps and snippets.

assistant: ### General

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

Custom Properties
:   Import user properties as [Custom Properties](../custom_properties.xhtml).

Enums As Strings
:   Store custom property enumeration values as strings.

### Geometry

Custom Normals
:   Import [custom normals](../../modeling/meshes/structure.xhtml#modeling-meshes-normals-custom),
    if available (otherwise Blender will compute them).

Subdivision Data
:   Import FBX subdivision information as
    [Subdivision Surface Modifiers](../../modeling/modifiers/generate/subdivision_surface.xhtml).

Vertex Colors
:   Import vertex color attributes.

    None:
    :   Do not import color attributes.

    sRGB:
    :   Vertex colors in the file are in sRGB [Color Space](../../glossary/index.xhtml#term-Color-Space)

    Linear:
    :   Vertex colors in the file are in Linear [Color Space](../../glossary/index.xhtml#term-Color-Space)

### 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.

### Animation

Offset
:   Offset to apply to animation timestamps, in frames.

### Armature

Ignore Leaf Bones
:   Ignore the last bone at the end of each chain (used to mark the length of the previous bone).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Grid
:   The input grid to sample from. The grid can store scalar, vector, or
    color data depending on its data type.

Position
:   The spatial positions (in object space) where the grid values are
    evaluated. Each position is interpolated based on nearby voxel values.

Interpolation
:   The interpolation method used to compute the sampled value between
    neighboring voxels:

    Nearest Neighbor:
    :   Returns the value from the closest voxel without interpolation.
        Fastest method but can appear blocky or discrete.

    Trilinear:
    :   Performs linear interpolation across the eight nearest voxels.
        Produces smooth transitions between samples and is suitable for most general uses.

    Triquadratic:
    :   Uses a higher-order (quadratic) interpolation for even smoother
        gradients and more continuous results, at the cost of additional computation.
user: What is GeometryNodeDeleteGeometry(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeDeleteGeometry(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.GeometryNodeDeleteGeometry(*GeometryNode*)
:   Remove selected elements of a geometry

    domain
    :   Which domain to delete in

        Type:
        :   enum in [Attribute Domain Without Corner Items](bpy_types_enum_items/attribute_domain_without_corner_items.html#rna-enum-attribute-domain-without-corner-items), default `'POINT'`

    mode
    :   Which parts of the mesh component to delete

        Type:
        :   enum in [`'ALL'`, `'EDGE_FACE'`, `'ONLY_FACE'`], default `'ALL'`

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

assistant: The slightest difference in seed values would result in completely different outputs.
Consequently, bad precision may have significant impact on the output.
Usually, we can mitigate this issue by:

- Eliminating the problematic seed value. If the problematic seed value is constant,
  it should be eliminated by choosing a lower dimension or multiplying it by zero.
- Adding an arbitrary value to the seed. The issue might only happen at certain boundaries,
  like unit boundaries, so simply adding an arbitrary value might solve the issue.
- Taking the absolute value of the seed. In computing, zero may be positive or negative,
  so taking the absolute values unifies the zero into a single value.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_white-noise_issue.png   Precision issue due to signed zeros on the Z axis. | ../../../_images/render_shader-nodes_textures_white-noise_solution1.png   Mitigating the issue by eliminating the Z axis. |
| ../../../_images/render_shader-nodes_textures_white-noise_solution2.png   Mitigating the issue by adding an arbitrary value. | ../../../_images/render_shader-nodes_textures_white-noise_solution3.png   Mitigating the issue by taking the absolute value. |
user: Provide the full official documentation entry for EvaluateClosureNodeViewerPathElem(ViewerPathElem), preserving all code examples.

assistant: # EvaluateClosureNodeViewerPathElem(ViewerPathElem)

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`Node.insert_link`](bpy.types.Node.html#bpy.types.Node.insert_link "bpy.types.Node.insert_link") - [`Node.internal_links`](bpy.types.Node.html#bpy.types.Node.internal_links "bpy.types.Node.internal_links") - [`NodeLink.swap_multi_input_sort_id`](#bpy.types.NodeLink.swap_multi_input_sort_id "bpy.types.NodeLink.swap_multi_input_sort_id") | - [`NodeLinks.new`](bpy.types.NodeLinks.html#bpy.types.NodeLinks.new "bpy.types.NodeLinks.new") - [`NodeLinks.remove`](bpy.types.NodeLinks.html#bpy.types.NodeLinks.remove "bpy.types.NodeLinks.remove") - [`NodeTree.links`](bpy.types.NodeTree.html#bpy.types.NodeTree.links "bpy.types.NodeTree.links") |
user: What is Masks and how is it used in Blender Python scripting?

assistant: [image reference removed]

A mask is used to control which vertices of the mesh are influenced by sculpting and painting.
The mask can for example be created/edited via the [Mask Gesture Tools](../tools/mask_tools.xhtml)
and [Mask by Color](../tools/mask_by_color.xhtml) tool.

Internally, masks are stored using the `sculpt_mask` [Attributes](../../../modeling/geometry_nodes/attributes_reference.xhtml).

### Clear & Invert

Creating masks follows a slightly different mental model than selecting in other modes.
For example `Shift`-`LMB` is used for smoothing instead of adding to a mask.

Masking is also conceptually inverted to selection
(i.e. You **cannot** edit masked vertices. But you **can** edit selected vertices).

Instead a mask is typically always added to the current mask with `LMB` and subtracted with `Ctrl`-`LMB`.
So if you wish to edit the masked surfaces, you’ll need to use the [Invert](../editing/mask.xhtml#mask-invert) operator,
In the case of masking everything that is visible,
the best workflow is to first [Clear](../editing/mask.xhtml#mask-clear) and then [Invert](../editing/mask.xhtml#mask-invert) the mask.

Both these operators can be quickly accessed in the `A` pie menu.

[image reference removed]
user: Explain Visualization in complete detail according to the official Blender documentation.

assistant: ### Bone State Colors

The color of the bones are based on their state.
There are six different color codes, ordered here by precedence
(i.e. the bone will be of the color of the bottom-most valid state):

- Gray: Default.
- Blue wire-frame: in Pose Mode.
- Green: with Constraint.
- Yellow: with [IK Solver constraint](../../constraints/tracking/ik_solver.xhtml).
- Orange: with Targetless Solver constraint.
user: Give a detailed overview of NodeGroupOutput(NodeInternal): syntax, arguments, return values, common patterns.

assistant: # NodeGroupOutput(NodeInternal)

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")

*class* bpy.types.NodeGroupOutput(*NodeInternal*)
:   Output data from inside of a node group

    is_active_output
    :   True if this node is used as the active group output

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

assistant: Domain
:   The domain on which the selection and group ID fields are evaluated.

    Point:
    :   The fields are evaluated on points, control points, and vertices.

    Edge:
    :   The fields are evaluated on the edges of the mesh component.

    Faces:
    :   The fields are evaluated on the faces of the mesh component.

    Spline:
    :   The fields are evaluated on the splines in the curve component.

    Instance:
    :   The fields are evaluated on the top-level instances. Realized instances are ignored.
user: Provide the full official documentation entry for Cloth with Wind, preserving all code examples.

assistant: [image reference removed]

Flag with wind applied.

Regression blend-file for Cloth with wind and self-collisions (also the blend for the image above):
[Cloth flag with wind and self-collisions](https://archive.blender.org/wiki/2015/index.php/File:Cloth-flag2.blend).
user: Show practical ways to work with Interpolate in a Blender add-on or script – include code.

assistant: When you are animating simple shapes you can use the interpolate tool
to automatically add new breakdown keyframes.

See [Interpolate tool](../modes/draw/tools/interpolate.xhtml#tool-grease-pencil-draw-interpolate) for more details.
user: Provide the full official documentation entry for Locking Bones, preserving all code examples.

assistant: You can prevent a bone from being transformed in *Edit Mode* in several ways:

- All bones can be locked clicking on the *Lock* checkbox
  of their Transform panel in the *Bones* tab;
- Press `Shift`-`W` Toggle Bone Options ‣ Locked
- Select Armature ‣ Bone Settings ‣ Toggle a Setting.

*If the root of a locked bone is connected to the tip of an unlocked bone, it will not be locked*,
i.e. you will be able to move it to your liking.
This means that in a chain of connected bones, when you lock one bone,
you only really lock its tip. With unconnected bones, the locking is effective on both joints of the bone.
user: Describe Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: - Viewer and inspection nodes may not display accurate values when closures are evaluated in multiple contexts.
- Captured external values are read-only and cannot be modified inside the evaluation.
- Closures currently cannot access attributes or data outside their evaluation context.
user: How do I use Error Messages in Blender? Include parameters, examples, warnings and best practices.

assistant: Vertex group *group_name* is not valid
:   This message is displayed when a user deletes the vertex group or changes its name.

Vertices changed from X to Y
:   This message is displayed when a user adds or deletes vertices to/from the mesh.

Edges changed from X to Y
:   This message is displayed when a user adds or deletes edges to/from the mesh.

The system did not find a solution
:   This message is displayed if the solver could not find a solution for the linear system.
user: Provide the full official documentation entry for XrUserPaths(bpy_struct), preserving all code examples.

assistant: # XrUserPaths(bpy_struct)

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

*class* bpy.types.XrUserPaths(*bpy_struct*)
:   Collection of OpenXR user paths

    new(*path*)
    :   new

        Parameters:
        :   **path** (*string**,* *(**never None**)*) – Path, OpenXR user path

        Returns:
        :   User Path, Added user path

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

    remove(*user_path*)
    :   remove

        Parameters:
        :   **user_path** ([`XrUserPath`](bpy.types.XrUserPath.html#bpy.types.XrUserPath "bpy.types.XrUserPath"), (never None)) – User Path

    find(*path*)
    :   find

        Parameters:
        :   **path** (*string**,* *(**never None**)*) – Path, OpenXR user path

        Returns:
        :   User Path, The user path with the given path

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

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

assistant: Show Only Selected
:   This option is only available if the object is in Edit Mode.
    When checked, only data for the selected geometry elements is shown.

Use Filter
:   Whether to use the filters that are defined in the Sidebar (see below).

### View Menu

Toolbar `T`
:   Show or hide the tab panel on the left for creating and manipulating markers and masks.

Sidebar `N`
:   Show or hide the [Sidebar](../interface/window_system/regions.xhtml#ui-region-sidebar).

---

Internal Attributes
:   Display attributes with names starting with a period that are meant for internal use.

---

Area
:   Area controls. See the [user interface](../interface/window_system/areas.xhtml)
    documentation for more information.
user: Describe Installing Blender from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender downloads can be extracted to any directory on the system, as
a self contained installation. Multiple Blender versions can
co-exist on the same system, and deployment can be automated using
standard file management tools.

New Blender versions may add, remove or change functionality that
affects the results of production files. For a given project, it is
advisable to use a single LTS version
of Blender. LTS versions receive bug fixes for two years.
user: Provide the full official documentation entry for Select Menu, preserving all code examples.

assistant: All `A`
:   Selects all keyframes.

None `Alt`-`A`
:   Deselects all keyframes.

Invert `Ctrl`-`I`
:   Inverts the selection.

---

[Box Select](../../interface/selecting.xhtml#bpy-ops-select-box) `B`
:   Lets you drag a box and selects the keyframes inside it.

Box Select (Axis Range) `Alt`-`B`
:   Lets you drag a box and selects the keyframes inside the corresponding time range,
    even if they’re above or below the box.

[Circle Select](../../interface/selecting.xhtml#bpy-ops-select-circle) `C`
:   Displays a circle around the cursor, which you can drag over keyframes to select them.

[Lasso Select](../../interface/selecting.xhtml#bpy-ops-select-lasso) `Ctrl`-`RMB`
:   Lets you draw a freehand shape and selects the keyframes inside it.

---

More `Ctrl`-`NumpadPlus`
:   Expand the selection to include the neighbors (in time) of the currently selected keys.

Less `Ctrl`-`NumpadMinus`
:   Deselect keyframes with fewer than two selected neighbors.

---

Select Linked `L`
:   Select keys that are on the same channel as a key that’s already selected.

---

Columns on Selected Keys `K`
:   Selects keys that are on the same frame as a key that’s already selected.

Column on Current Frame `Ctrl`-`K`
:   Selects all the keys that are on the current frame.

Columns on Selected Markers `Shift`-`K`
:   Selects keys that are on the same frame as a selected marker.

Between Selected Markers `Alt`-`K`
:   Selects keys that lie between the leftmost and rightmost selected markers.

---

Before Current Frame `[`
:   Select the keys that lie before (or on) the current frame.
    You can also click `Shift`-`Ctrl`-`LMB` anywhere to the left of the Playhead.

After Current Frame `]`
:   Select the keys that lie after (or on) the current frame.
    You can also click `Shift`-`Ctrl`-`LMB` anywhere to the right of the Playhead.
user: Give a detailed overview of Custom Properties: syntax, arguments, return values, common patterns.

assistant: # Custom Properties

[image reference removed]

Custom Properties panel.

Custom properties are a way to store your own data in Blender’s data-blocks. It can be used for rigging
(where bones and objects can have custom properties driving other properties), and Python scripts,
where it’s common to define new settings not available in Blender. It is also possible to access
custom properties from materials via the [Attribute Node](../render/shader_nodes/input/attribute.xhtml).

Only certain data supports custom properties:

- All [data-blocks types](data_blocks.xhtml#data-system-datablock-types).
- Bones and pose bones.
- Sequence strips.

To add a custom property, search for the *Custom Properties* panel,
found at the bottom of most [Properties](../editors/properties_editor.xhtml) or Sidebar region, and click *New*.
Properties can be removed from the same location with the delete icon.
Once properties are added they can be configured via the edit icon to work for a particular use case;
see [Editing Properties](#editing-properties) for more information.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Opacity Factor samples.

|  |  |  |
| --- | --- | --- |
| ../../../_images/grease-pencil_modifiers_color_texture-mapping_1.png   Rotation: 0°. | ../../../_images/grease-pencil_modifiers_color_texture-mapping_2.png   Rotation: 45°. | ../../../_images/grease-pencil_modifiers_color_texture-mapping_3.png   Rotation: 90°. |
user: Give a detailed overview of Algorithm: syntax, arguments, return values, common patterns.

assistant: The calculation done by the *Smooth* modifier is a simple and logical one,
and can be thought of as the geometric equivalent of blurring images.

Each new vertex position is simply moved towards the average position of all its neighbor vertices
(topologically speaking, i.e. the vertices directly connected to it by an edge).
user: Provide the full official documentation entry for GeometryNodeCurveOfPoint(GeometryNode), preserving all code examples.

assistant: # GeometryNodeCurveOfPoint(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.GeometryNodeCurveOfPoint(*GeometryNode*)
:   Retrieve the curve a control point is part of

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

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

assistant: Is Hit
:   Boolean output that is true for each ray which has hit the *Target Geometry*.

Hit Position
:   The location of the intersection point with the target mesh.

Hit Normal
:   The surface [Normal](../../../../glossary/index.xhtml#term-Normal) vector at the hit location.

Hit Distance
:   The distance from the *Source Position* to the *Hit Position*.
    If the ray does not hit, the *Ray Length* is returned.

Attribute
:   Interpolated values of the *Attribute* input sampled at the *Hit Position*.
user: Give a detailed overview of Bpy.Types.Particlesettingstextureslot: syntax, arguments, return values, common patterns.

assistant: Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values TextureSlot.bl_rna_get_subclass TextureSlot.bl_rna_get_subclass_py References ¶ ParticleSettings.texture_slots ParticleSettingsTextureSlots.add ParticleSettingsTextureSlots.create Next ParticleSettingsTextureSlots(bpy_struct) Previous ParticleSettings(ID) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page ParticleSettingsTextureSlot(TextureSlot) ParticleSettingsTextureSlot ParticleSettingsTextureSlot.clump_factor ParticleSettingsTextureSlot.damp_factor ParticleSettingsTextureSlot.density_factor ParticleSettingsTextureSlot.field_factor ParticleSettingsTextureSlot.gravity_factor ParticleSettingsTextureSlot.kink_amp_factor ParticleSettingsTextureSlot.kink_freq_factor ParticleSettingsTextureSlot.length_factor ParticleSettingsTextureSlot.life_factor ParticleSettingsTextureSlot.mapping ParticleSettingsTextureSlot.mapping_x ParticleSettingsTextureSlot.mapping_y ParticleSettingsTextureSlot.mapping_z ParticleSettingsTextureSlot.object ParticleSettingsTextureSlot.rough_factor ParticleSettingsTextureSlot.size_factor ParticleSettingsTextureSlot.texture_coords ParticleSettingsTextureSlot.time_factor ParticleSettingsTextureSlot.twist_factor ParticleSettingsTextureSlot.use_map_clump ParticleSettingsTextureSlot.use_map_damp ParticleSettingsTextureSlot.use_map_density ParticleSettingsTextureSlot.use_map_field ParticleSettingsTextureSlot.use_map_gravity ParticleSettingsTextureSlot.use_map_kink_amp ParticleSettingsTextureSlot.use_map_kink_freq ParticleSettingsTextureSlot.use_map_length ParticleSettingsTextureSlot.use_map_life ParticleSettingsTextureSlot.use_map_rough ParticleSettingsTextureSlot.use_map_size ParticleSettingsTextureSlot.use_map_time ParticleSettingsTextureSlot.use_map_twist ParticleSettingsTextureSlot.use_map_velocity ParticleSettingsTextureSlot.uv_layer ParticleSettingsTextureSlot.velocity_factor ParticleSettingsTextureSlot.bl_rna_get_subclass() ParticleSettingsTextureSlot.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe Object Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Object Type Items

MESH:
:   Mesh.

CURVE:
:   Curve.

SURFACE:
:   Surface.

META:
:   Metaball.

FONT:
:   Text.

CURVES:
:   Hair Curves.

POINTCLOUD:
:   Point Cloud.

VOLUME:
:   Volume.

GREASEPENCIL:
:   Grease Pencil.

---

ARMATURE:
:   Armature.

LATTICE:
:   Lattice.

---

EMPTY:
:   Empty.

---

LIGHT:
:   Light.

LIGHT_PROBE:
:   Light Probe.

---

CAMERA:
:   Camera.

---

SPEAKER:
:   Speaker.
user: Provide the full official documentation entry for limbs.paw, preserving all code examples.

assistant: Will create a fully featured bendy and stretchy paw depending on the user-defined options.

Requirement: A chain of four or five connected bones (thigh, shin, paw, *optional* digit, toe).

[image reference removed]

Front/Rear paw required bones.

Rotation Axis (Automatic, X, Z)
:   Defines the bend axis for the IK chain. FK chains will have a totally free degree of rotation on all axes.

Limb Segments (integer)
:   Defines the number of additional tweak controls each limb bone will have on the final rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Custom IK Pivot
:   Generates an extra control for the end of the IK limb that allows rotating it around an arbitrarily placed pivot.

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

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.
user: Show practical ways to work with Tips for Nice Setups in a Blender add-on or script – include code.

assistant: - For optimal deformations, it is recommended that the bones are roughly the same length,
  and that they are not too long, to facilitate a better fit to the curve.
  Also, bones should ideally be created in a way that follows the shape of the curve in its ‘rest pose’ shape,
  to minimize the problems in areas where the curve has sharp bends
  which may be especially noticeable when stretching is disabled.
- For control of the curve, it is recommended that hooks (in particular, Bone Hooks)
  are used to control the control points of the curve, with one hook per control point.
  In general, only a few control points should be needed for the curve
  (e.g. one for every 3-5 bones offers decent control).
- The type of curve used does not really matter,
  as long as a path can be extracted from it that could also be used by the Follow Path Constraint.
  This really depends on the level of control required from the hooks.
user: What is Limitations and how is it used in Blender Python scripting?

assistant: Most constraints of Blender as an application still apply:

Reloading Unsupported
:   Reloading the `bpy` module via `importlib.reload` will raise an exception
    instead of reloading and resetting the module.

    Instead, the operator `bpy.ops.wm.read_factory_settings()` can be used to reset the internal state.

Single Blend File Restriction
:   Only a single `.blend` file can be edited at a time.
user: Show practical ways to work with Pose Options in a Blender add-on or script – include code.

assistant: ### Auto IK

Automatic IK is a tool for quick posing, when enabled, translating a bone will activate
inverse kinematics and rotate the parent bone, and the parent’s parent, and so on, to
follow the selected bone. The IK chain can only extend from a child to a parent bone
if the child is *connected* to it.

While moving bones, the length of the chain (the number of affected bones)
can be increased or decreased using keyboard hotkeys.
Pressing `PageUp` will increase in chain length by one
and `PageDown` decreases the length by one.
The chain length can also be controlled with `WheelUp` or `WheelDown`.

The initial chain length is 0, which effectively means follow
the connections to parent bones as far as possible, with no length limit.
So pressing increasing the chain length the first time sets the length to 1 (move only the selected bone),
and at this point, decreasing the length point sets it back to 0 (unlimited) again.
Thus, you have to increase the chain length *more than once* from the initial state
to set a finite chain length greater than 1.

This is a more limited feature than using an IK constraint,
which can be configured, but it can be useful for quick posing.

### X-Axis Mirror

This option enables automatic mirroring of editing actions along the X axis.
You can enable this option in the Tool tab ‣ Options panel,
while the armature is selected in *Edit Mode*.
When you have pairs of bones of the same name with just a different “side suffix”
(e.g. “.R”/”.L”, or “_right”/”_left” …), once this option is enabled,
each time you transform (move, rotate, scale…) a bone,
its “other side” counterpart will be transformed accordingly,
through a symmetry along the armature local X axis.
As most rigs have at least one axis of symmetry (animals, humans, …),
it is an easy way to keep the model symmetrical.

### Relative Mirror

Accounts for any relative transformations when using *X-Axis Mirror*.
user: Show practical ways to work with Header in a Blender add-on or script – include code.

assistant: [image reference removed]

Sort order of the channels.

Only Show Selected
:   Limits Dope Sheet channels to only information about selected tracks.

Display Hidden
:   Includes information from hidden tracks.

Dopesheet Sort Field
:   Sort order of the tracks.

    Name:
    :   Sort selected tracks in alphabetical order based on their names.

    Longest:
    :   Sort tracks by longest tracked segment length.

    Total:
    :   Sort tracks by overall amount of frames.

    Average Error:
    :   Sort tracks by their average reprojection error after solving camera or object motion.

    Start Frame:
    :   Sort channels by first frame number.

    End Frame:
    :   Sort channels by last frame number.

Invert
:   To change the sort order from ascending to descending.
user: Describe Creating a Kernel in the Compositor from the Blender manual or Python API, including usage steps and snippets.

assistant: Kernels can be created directly inside the compositor using Blender’s existing nodes,
without the need for an external image.

This approach is useful for designing procedural or parameterized filters, blurs,
and glare patterns that can be modified interactively.

1. **Start with a Constant Image**
   Use an [Image Node](types/input/image.xhtml) set to a small resolution,
   such as 9x9 or 15x15 pixels.
   Alternatively, generate a solid color using a [RGB](types/input/constant/rgb.xhtml) node.
2. **Shape the Kernel**
   Modify the pixel values to define the kernel weights:

   - Use the [Ellipse Mask](types/mask/ellipse_mask.xhtml) or
     [Blur](types/filter/blur/blur.xhtml) nodes to create soft, circular falloffs.
   - Combine multiple masks with [Mix](types/color/mix_color.xhtml) nodes to form
     complex or directional shapes (for example, a star or streak pattern).

   Scale the overall strength using a [Math](types/utilities/math/math.xhtml) node
   in *Multiply* mode, or normalize the kernel values by dividing by their total sum.
3. **Feed into the Convolve Node**
   Connect the resulting procedural image to the *Kernel* input of the
   [Convolve Node](types/filter/convolve.xhtml).
   The pattern and brightness of this image directly control the convolution effect.

### Tips

- Small images (under 20x20 pixels) produce efficient, responsive kernels.
- Use *Normalize Kernel* in the *Convolve* node to maintain brightness balance automatically.
- Animated masks or procedural noise patterns can be used to create dynamic or flickering filter effects.
- Kernels with positive and negative values can be used to emphasize edges or textures.
user: Explain Unwrap in complete detail according to the official Blender documentation.

assistant: Blender offers several ways of mapping UVs.
The simpler projection methods use formulas that map 3D space onto 2D space,
by interpolating the position of points toward a point, axis or plane through a surface.
The more advanced methods can be used with more complex models, and have more specific uses.

- [Unwrap](../editing/uv.xhtml#bpy-ops-uv-unwrap)
- [Smart UV Project](../editing/uv.xhtml#bpy-ops-uv-smart-project)
- [Lightmap Pack](../editing/uv.xhtml#bpy-ops-uv-lightmap-pack)
- [Follow Active Quads](../editing/uv.xhtml#bpy-ops-uv-follow-active-quads)
- [Cube Projection](../editing/uv.xhtml#bpy-ops-uv-cube-project)
- [Cylinder Projection](../editing/uv.xhtml#bpy-ops-uv-cylinder-project)
- [Sphere Projection](../editing/uv.xhtml#bpy-ops-uv-sphere-project)
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

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

The Explode modifier, with a Particle System above it.

Particle UV
:   If set, the U value of the coordinates in that [UV Map](../../../glossary/index.html#term-UV-Map) will be overwritten
    with the age of the particle attached to the matching mesh face
    (in proportion, from 0 for not yet born particles, to 1 for dead ones).

    The V value is set to a constant 0.5 value.

    You can for example vary the color of a fragment (face) during the explosion phase,
    by using a texture with a color gradient along its *U* axis.

Show
:   Unborn
    :   Show faces when their attached particles are unborn.

    Alive
    :   Show faces when their attached particles are alive.

    Dead
    :   Show faces when their attached particles are dead.

Cut Edges
:   Split the mesh in pieces based on location of emitted particles, instead of using existing faces.
    This will typically results in a splitting that appears more random.

Size
:   Scale each face using the size of its attached particle, once that particle is alive.

Vertex Group
:   Vertices in this group may not be affected by the *Explode* modifier.
    Vertices with full weight are not affected at all,
    while vertices with less weight have a higher chance of being affected.

    Vertices with null weight will be treated like those which do not belong to the group at all,
    and explode normally.

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

        The setting reverses the weight values of the group.

Protect
:   Clean vertex group edges. Depending on the weights assigned to that vertex group,
    either completely protect those faces from being affected by the *Explode* modifier
    (which would happen if the faces had a weight value of 1),
    or completely remove protection from those faces
    (which would happen if the faces had a weight value of 0).

Refresh
:   Refresh data in the *Explode* modifier.
user: How do I use Curve Segment in Blender? Include parameters, examples, warnings and best practices.

assistant: # Curve Segment

The *Curve Segment* node provides information about the segment connecting
each point on a curve to its previous point.
It is useful for analyzing or manipulating per-segment data, such as length,
direction, or connectivity, and for constructing effects that depend on local curve structure.