PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Start Editing Stashed Action in a Blender add-on or script – include code.

assistant: Enters Tweak Mode for the selected strip’s action, making its keyframes available for editing in
e.g. the [Graph Editor](../../graph_editor/introduction.html). In addition, marks the strip’s
track as *Solo*, muting all the other tracks – this way, they no longer influence the animation
and you can focus exclusively on the action you’re editing.

While the menu item refers to stashed (muted) actions, this only reflects the typical use case.
It works on unmuted actions as well.

When you’re done editing, click Strip ‣ Stop Editing Stashed Action
or press `Shift`-`Tab` again.

|  |  |
| --- | --- |
| <../../../_images/editors_nla_editing_nla-mode.png>   Strip in NLA mode. | <../../../_images/editors_nla_editing_edit-mode.png>   Strip in Tweak mode. |
user: Give a detailed overview of Bpy.Types.Collection: syntax, arguments, return values, common patterns.

assistant: a_ancestors bpy_struct.type_recast bpy_struct.values ID.bl_system_properties_get ID.rename ID.evaluated_get ID.copy ID.asset_mark ID.asset_clear ID.asset_generate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py References ¶ BlendData.collections BlendDataCollections.new BlendDataCollections.remove BooleanModifier.collection ClothCollisionSettings.collection Collection.children CollectionChildren.link CollectionChildren.unlink Context.collection DopeSheet.filter_collection DynamicPaintSurface.brush_collection EffectorWeights.collection FluidDomainSettings.effector_group FluidDomainSettings.fluid_group FluidDomainSettings.force_collection FreestyleLineSet.collection GeometryNodeInputCollection.collection GreasePencilLineartModifier.source_collection IDOverrideLibrary.resync LayerCollection.collection LightProbe.visibility_collection NodeSocketCollection.default_value NodeTreeInterfaceSocketCollection.default_value ObjectLightLinking.blocker_collection ObjectLightLinking.receiver_collection Object.instance_collection ParticleSettings.collision_collection ParticleSettings.instance_collection RigidBodyWorld.collection RigidBodyWorld.constraints Scene.collection SoftBodySettings.collision_collection Next CollectionChild(bpy_struct) Previous CloudsTexture(Texture) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Collection(ID) Collection Collection.active_exporter_index Collection.all_objects Collection.children Collection.collection_children Collection.collection_objects Collection.color_tag Collection.exporters Collection.hide_render Collection.hide_select Collection.hide_viewport Collection.instance_offset Collection.lineart_intersection_mask Collection.lineart_intersection_priority Collection.lineart_usage Collection.lineart_use_intersection_mask Collection.objects Collection.use_lineart_intersection_priority Collection.children_recursive Collection.users_dupli_group Collection.bl_rna_get_subclass() Collection.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Tangent
:   The tangent direction vector derived from the input UV map.
    The output is a normalized vector field that lies along the surface and
    indicates the direction of increasing *U* values in the UV space.
    It can be combined with normals and bitangents for constructing a complete tangent space basis.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Float2Attribute.data`](bpy.types.Float2Attribute.html#bpy.types.Float2Attribute.data "bpy.types.Float2Attribute.data") | - [`MeshUVLoopLayer.uv`](bpy.types.MeshUVLoopLayer.html#bpy.types.MeshUVLoopLayer.uv "bpy.types.MeshUVLoopLayer.uv") |
user: Show practical ways to work with Settings in a Blender add-on or script – include code.

assistant: # Settings

[image reference removed]

Default rigid body panel.

Mass
:   Specifies how heavy the object is and “weights” irrespective of gravity.

Dynamic
:   Enables/disables rigid body simulation for the object.

Animated
:   Allows the rigid body to additionally be controlled by the animation system.
user: Show practical ways to work with Generating the Set of Files for the Target Language in a Blender add-on or script – include code.

assistant: 1. Check out the current translation repository using the command:

   ```
   git clone https://projects.blender.org/blender/blender-manual-translations.git locale
   ```

   This will download all language sets available in the repository into the `locale` directory of your drive. You
   can go to the `locale` directory to see the hidden subdirectory `.git` within it, together with directories of
   languages. You’ll need to add your own set of files for the language you are trying to translating to.
2. From the `blender-manual` directory to generate a set of files for `fr` language:

   ```
   make update_po
   ```

   These files are still in English only, with all `msgstr` entries blank.
3. Submit new set of files to the central repository:

   ```
   cd locale
   git add fr
   git commit -m "Initial commit language set of files for French"
   ```
user: Give a detailed overview of Simple Contribution: syntax, arguments, return values, common patterns.

assistant: The preferred way to contribute to the translation effort is via the
[web-based interface](https://translate.blender.org/projects/blender-manual/manual), currently hosted on Weblate.

Suggestions for translations can be contributed without logging in. They will be reviewed by the translation team
before being published.

Weblate also provides tools such as the
[glossary](https://translate.blender.org/projects/blender-manual/glossary/) to improve translation consistency.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Noise Modifier.

Position
:   Strength of the noise effect over the point location.

Strength
:   Strength of the noise effect over the point strength (opacity).

Thickness
:   Strength of the noise effect over the point thickness.

UV
:   Strength of the noise effect over the point UV rotation.

Noise Scale
:   Control the noise frequency scale.

Noise Offset
:   Moves the noise along the strokes.

Seed
:   [Seed](../../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

### Randomize

When enabled, the noise uses a random value over time.

Mode
:   Steps:
    :   New random value at defined steps.

        Step
        :   Number of frames before using a new random value.

    Keyframes:
    :   New random value only on keyframes.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of NodeSocketVectorFactor4D(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketVectorFactor4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorFactor4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

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

assistant: # ShaderNodeGamma(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeGamma(*ShaderNode*)
:   Apply a gamma correction

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # SceneObjects(bpy_struct)

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

*class* bpy.types.SceneObjects(*bpy_struct*)
:   All of the scene objects

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

assistant: # Bake Target Items

IMAGE_TEXTURES:
:   Image Textures.

    Bake to image data-blocks associated with active image texture nodes in materials.

VERTEX_COLORS:
:   Active Color Attribute.

    Bake to the active color attribute on meshes.
user: Explain BoolAttributeValue(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BoolAttributeValue(bpy_struct)

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

*class* bpy.types.BoolAttributeValue(*bpy_struct*)
:   Bool value in geometry attribute

    value
    :   Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

Strength
:   The strength of the smoothing is relative to the density of the mesh.
    If the resolution is increased on the sculpted mesh,
    the strength of the smooth brush will be weaker than before and needs to be increased.

Direction `Ctrl`
:   Smooth
    :   Smooths the surface of the mesh.

    Enhance Details
    :   Enhances details on the surface of the mesh by applying a smoothing operation in the opposite direction.

### Unique

Deformation
:   There are two deformation types.

    Laplacian:
    :   Smooths the surface and volumes. This is the default behavior.

    Surface:
    :   Smooths only the surface of the mesh, while preserving the volume.

        Shape Preservation
        :   How much of the original shape is preserved while smoothing. Increasing the value
            reduces the effect of having multiple iterations on the strength of smoothing.

        Per-Vertex Displacement
        :   How much the position of each individual vertex influences the final result.
            Increasing the value reduces the overall strength of smoothing.

        Iterations
        :   Number of smoothing iterations per brush step.
user: Explain Color in complete detail according to the official Blender documentation.

assistant: # Color

Paint Mode
:   Controls the source of the stroke color.
    The mode can be pinned to the brush by enabling the Pin icon in the Tool Settings header.

    Material:
    :   Use the stroke/fill base color material.

    Color Attribute:
    :   Use Color Attribute.

Color Picker
:   Sets the primary brush color.

Color, Secondary Color
:   The color of the brush. See [Color Picker](../../../../interface/controls/templates/color_picker.xhtml#ui-color-picker).

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.

    Stroke & Fill:
    :   Paint over strokes and fill areas.

Mix Factor
:   Mixing factor between the selected color and the base material color.
user: Provide the full official documentation entry for Miscellaneous, preserving all code examples.

assistant: Slide Spline Curvature `LMB`
:   Moves the curve and/or control points by clicking on them and dragging.

Add Vertex and Slide `Ctrl`-`LMB`
:   Inserts new control points and defines handle orientations by a continued mouse drag.
    If the last point was selected, double-click will also close the curve.

Add Feather Vertex and Slide `Shift`-`Ctrl`-`LMB`
:   Inserts new feather control points that can be transformed independently of the main spline curve.
    If no feather mask is in use this will create a basic feather mask to the curve.
user: What is Operator Return Items and how is it used in Blender Python scripting?

assistant: # Operator Return Items

RUNNING_MODAL:
:   Running Modal.

    Keep the operator running with blender.

CANCELLED:
:   Cancelled.

    The operator exited without doing anything, so no undo entry should be pushed.

FINISHED:
:   Finished.

    The operator exited after completing its action.

PASS_THROUGH:
:   Pass Through.

    Do nothing and pass the event on.

INTERFACE:
:   Interface.

    Handled but not executed (popup menus).
user: Give a detailed overview of Hair Curves Noise: syntax, arguments, return values, common patterns.

assistant: # Hair Curves Noise

The *Hair Curves Noise* node adds procedural noise-based deformation to hair curves,
creating natural-looking randomness or turbulence.
This can be used to simulate effects such as wind disturbance, curly or wavy hair,
or subtle irregularities in a groom.
user: Describe Int2AttributeValue(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Int2AttributeValue(bpy_struct)

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

*class* bpy.types.Int2AttributeValue(*bpy_struct*)
:   2D value in geometry attribute

    value
    :   2D vector

        Type:
        :   int array of 2 items in [-inf, inf], default (0, 0)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Here, the compare node is used with the *Direction* mode to compare the direction of the
sphere’s [face normals](../../geometry/read/normal.html) to the “direction”
of the cube object’s location. Anywhere that the directions are less than 32.9 degrees apart,
the faces will be selected, and deleted.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`ShaderNodeTexBrick.texture_mapping`](bpy.types.ShaderNodeTexBrick.html#bpy.types.ShaderNodeTexBrick.texture_mapping "bpy.types.ShaderNodeTexBrick.texture_mapping") - [`ShaderNodeTexChecker.texture_mapping`](bpy.types.ShaderNodeTexChecker.html#bpy.types.ShaderNodeTexChecker.texture_mapping "bpy.types.ShaderNodeTexChecker.texture_mapping") - [`ShaderNodeTexEnvironment.texture_mapping`](bpy.types.ShaderNodeTexEnvironment.html#bpy.types.ShaderNodeTexEnvironment.texture_mapping "bpy.types.ShaderNodeTexEnvironment.texture_mapping") - [`ShaderNodeTexGabor.texture_mapping`](bpy.types.ShaderNodeTexGabor.html#bpy.types.ShaderNodeTexGabor.texture_mapping "bpy.types.ShaderNodeTexGabor.texture_mapping") - [`ShaderNodeTexGradient.texture_mapping`](bpy.types.ShaderNodeTexGradient.html#bpy.types.ShaderNodeTexGradient.texture_mapping "bpy.types.ShaderNodeTexGradient.texture_mapping") - [`ShaderNodeTexImage.texture_mapping`](bpy.types.ShaderNodeTexImage.html#bpy.types.ShaderNodeTexImage.texture_mapping "bpy.types.ShaderNodeTexImage.texture_mapping") | - [`ShaderNodeTexMagic.texture_mapping`](bpy.types.ShaderNodeTexMagic.html#bpy.types.ShaderNodeTexMagic.texture_mapping "bpy.types.ShaderNodeTexMagic.texture_mapping") - [`ShaderNodeTexNoise.texture_mapping`](bpy.types.ShaderNodeTexNoise.html#bpy.types.ShaderNodeTexNoise.texture_mapping "bpy.types.ShaderNodeTexNoise.texture_mapping") - [`ShaderNodeTexSky.texture_mapping`](bpy.types.ShaderNodeTexSky.html#bpy.types.ShaderNodeTexSky.texture_mapping "bpy.types.ShaderNodeTexSky.texture_mapping") - [`ShaderNodeTexVoronoi.texture_mapping`](bpy.types.ShaderNodeTexVoronoi.html#bpy.types.ShaderNodeTexVoronoi.texture_mapping "bpy.types.ShaderNodeTexVoronoi.texture_mapping") - [`ShaderNodeTexWave.texture_mapping`](bpy.types.ShaderNodeTexWave.html#bpy.types.ShaderNodeTexWave.texture_mapping "bpy.types.ShaderNodeTexWave.texture_mapping") |
user: What is Mask Strip and how is it used in Blender Python scripting?

assistant: # Mask Strip

The Mask strip generates a mask image from the selected mask data-block generated
in the [Movie Clip Editor](../../../../movie_clip/masking/index.xhtml).
This works similar to the [Mask Node](../../../../compositing/types/input/mask.xhtml)
but without the options available for finer control.
The mask image is always generated at the render resolution,
scaling along with different proxy levels.
user: What is Limitations and how is it used in Blender Python scripting?

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: What is Export Grease Pencil as PDF and how is it used in Blender Python scripting?

assistant: # Export Grease Pencil as PDF

The Portable Document Format (PDF) is used to exchange documents that can be viewed with many applications, such as
PDF readers and modern browsers. Exporting Grease Pencil animations will create a separate page in the PDF document
for each frame selected.
user: How do I use Import Anim Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Import Anim Operators

bpy.ops.import_anim.bvh(*\**, *filepath=''*, *filter_glob='\*.bvh'*, *target='ARMATURE'*, *global_scale=1.0*, *frame_start=1*, *use_fps_scale=False*, *update_scene_fps=False*, *update_scene_duration=False*, *use_cyclic=False*, *rotate_mode='NATIVE'*, *axis_forward='-Z'*, *axis_up='Y'*)
:   Load a BVH motion capture file

    Parameters:
    :   - **filepath** (*string**,* *(**optional**,* *never None**)*) – File Path, Filepath used for importing the file
        - **filter_glob** (*string**,* *(**optional**,* *never None**)*) – filter_glob
        - **target** (enum in [`'ARMATURE'`, `'OBJECT'`], (optional)) – Target, Import target type
        - **global_scale** (*float in* *[**0.0001**,* *1e+06**]**,* *(**optional**)*) – Scale, Scale the BVH by this value
        - **frame_start** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Start Frame, Starting frame for the animation
        - **use_fps_scale** (*boolean**,* *(**optional**)*) – Scale FPS, Scale the framerate from the BVH to the current scenes, otherwise each BVH frame maps directly to a Blender frame
        - **update_scene_fps** (*boolean**,* *(**optional**)*) – Update Scene FPS, Set the scene framerate to that of the BVH file (note that this nullifies the ‘Scale FPS’ option, as the scale will be 1:1)
        - **update_scene_duration** (*boolean**,* *(**optional**)*) – Update Scene Duration, Extend the scene’s duration to the BVH duration (never shortens the scene)
        - **use_cyclic** (*boolean**,* *(**optional**)*) – Loop, Loop the animation playback
        - **rotate_mode** (enum in [`'QUATERNION'`, `'NATIVE'`, `'XYZ'`, `'XZY'`, `'YXZ'`, `'YZX'`, `'ZXY'`, `'ZYX'`], (optional)) –

          Rotation, Rotation conversion

          - `QUATERNION`
            Quaternion – Convert rotations to quaternions.
          - `NATIVE`
            Euler (Native) – Use the rotation order defined in the BVH file.
          - `XYZ`
            Euler (XYZ) – Convert rotations to euler XYZ.
          - `XZY`
            Euler (XZY) – Convert rotations to euler XZY.
          - `YXZ`
            Euler (YXZ) – Convert rotations to euler YXZ.
          - `YZX`
            Euler (YZX) – Convert rotations to euler YZX.
          - `ZXY`
            Euler (ZXY) – Convert rotations to euler ZXY.
          - `ZYX`
            Euler (ZYX) – Convert rotations to euler ZYX.
        - **axis_forward** (enum in [`'X'`, `'Y'`, `'Z'`, `'-X'`, `'-Y'`, `'-Z'`], (optional)) – Forward
        - **axis_up** (enum in [`'X'`, `'Y'`, `'Z'`, `'-X'`, `'-Y'`, `'-Z'`], (optional)) – Up

    File:
    :   [addons_core/io_anim_bvh/__init__.py:118](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/io_anim_bvh/__init__.py#L118)
user: Provide the full official documentation entry for – Rendered, preserving all code examples.

assistant: Render the 3D Viewport using the scene’s *Render Engine*, for interactive rendering.
This gives a preview of the final result before compositing, including scene lighting effects.

The options are the same as for *Material Preview*, except that
the *Render Pass* selector will offer different passes if the scene
uses the [Cycles](../../../render/cycles/introduction.html) render engine.
user: Provide the full official documentation entry for Brush Curve Preset Items, preserving all code examples.

assistant: # Brush Curve Preset Items

CUSTOM:
:   Custom.

SMOOTH:
:   Smooth.

SMOOTHER:
:   Smoother.

SPHERE:
:   Sphere.

ROOT:
:   Root.

SHARP:
:   Sharp.

LIN:
:   Linear.

POW4:
:   Sharper.

INVSQUARE:
:   Inverse Square.

CONSTANT:
:   Constant.
user: What is Asset Previews and how is it used in Blender Python scripting?

assistant: [image reference removed]

Preview panel in the Asset Browser.

Preview images are typically generated automatically when you [mark a data-block as an asset](../files/asset_libraries/introduction.html#bpy-ops-asset-mark). Objects are captured from their local -Y axis, while collections are captured from the global
-Y axis (as these don’t have a local axis).

If the auto-generated preview image isn’t sufficient, you can replace it by a custom one.

For previews of pose assets, see [Controlling the Look of Preview Images](../animation/armatures/posing/editing/pose_library.html#poselib-preview-images).

### Screenshot Capture for Previews

In case a specific preview is needed, a fast way to create it is with a screenshot.
The operator to do so is located under the Preview popover, see [Capture Screenshot Preview](#bpy-ops-asset-screenshot-preview).
It is only possible to take screenshots for editable assets,
so assets in the [Current File](../files/asset_libraries/introduction.html#asset-library-current-file)
and [Asset System Files](../files/asset_libraries/introduction.html#asset-system-files).

Once started, you can click and drag a rectangular area over any part of Blender to capture a preview image.
During dragging it is possible to move the whole capture area or to unlock the aspect ratio.
See the shortcut help in the status bar for information on which keys to press.

On a re-run of the operator, the previously captured area will be remembered.
Simply clicking allows you to easily take the same screenshot again.
user: Describe Subdivide Curve Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Subdivide Curve Node

[image reference removed]

The *Subdivide Curve* node adds more control points in between existing control points on the curve input.
For Bézier and poly splines, the shape of the spline will not be changed at all.

With Bézier curves, this can be used to increase the control on the shape of the curve
while still having the higher-level provided by Bézier splines.
Unlike the [Resample Curve Node](resample_curve.xhtml), where they are converted to poly splines.
user: Give a detailed overview of Attributes: syntax, arguments, return values, common patterns.

assistant: # Attributes

An *attribute* is a generic term to describe data stored per-element in a geometry data-block.
For example, every vertex can have an associated number or vector.
Attributes can be altered by connecting a value to the *Group Output* node,
but also many nodes can change the values of specific attributes.
user: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FModifier.name`](bpy.types.FModifier.html#bpy.types.FModifier.name "bpy.types.FModifier.name") - [`FModifier.type`](bpy.types.FModifier.html#bpy.types.FModifier.type "bpy.types.FModifier.type") - [`FModifier.show_expanded`](bpy.types.FModifier.html#bpy.types.FModifier.show_expanded "bpy.types.FModifier.show_expanded") - [`FModifier.mute`](bpy.types.FModifier.html#bpy.types.FModifier.mute "bpy.types.FModifier.mute") - [`FModifier.is_valid`](bpy.types.FModifier.html#bpy.types.FModifier.is_valid "bpy.types.FModifier.is_valid") - [`FModifier.active`](bpy.types.FModifier.html#bpy.types.FModifier.active "bpy.types.FModifier.active") | - [`FModifier.use_restricted_range`](bpy.types.FModifier.html#bpy.types.FModifier.use_restricted_range "bpy.types.FModifier.use_restricted_range") - [`FModifier.frame_start`](bpy.types.FModifier.html#bpy.types.FModifier.frame_start "bpy.types.FModifier.frame_start") - [`FModifier.frame_end`](bpy.types.FModifier.html#bpy.types.FModifier.frame_end "bpy.types.FModifier.frame_end") - [`FModifier.blend_in`](bpy.types.FModifier.html#bpy.types.FModifier.blend_in "bpy.types.FModifier.blend_in") - [`FModifier.blend_out`](bpy.types.FModifier.html#bpy.types.FModifier.blend_out "bpy.types.FModifier.blend_out") - [`FModifier.use_influence`](bpy.types.FModifier.html#bpy.types.FModifier.use_influence "bpy.types.FModifier.use_influence") - [`FModifier.influence`](bpy.types.FModifier.html#bpy.types.FModifier.influence "bpy.types.FModifier.influence") |
user: Show practical ways to work with Brushes in a Blender add-on or script – include code.

assistant: # Brushes

This is a list of all provided ‘Essentials’ brush assets that come with Blender.
These are based on various [Brush Types](../../brush/brush_settings.html#sculpt-tool-settings-brush-type) which are mentioned for each brush..
user: Explain Volumetrics in complete detail according to the official Blender documentation.

assistant: - Only single scattering is supported.
- Volumetrics are rendered only for the camera “rays”. They don’t appear in reflections/refractions and probes.
- Volumetric shadowing only work in volumetrics. They won’t cast shadows onto solid objects in the scene.
- Volumetric shadowing only work for volumes inside the view frustum.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Object
:   Object to get the properties from.

As Instance
:   Output the entire object as single instance instead of realized geometry.
    This allows instancing non-geometry object types, because the output will contain an instance of the object.
user: What is Triangulate Node and how is it used in Blender Python scripting?

assistant: # Triangulate Node

[image reference removed]

The *Triangulate* node converts all faces in a mesh (quads and n-gons) to triangular faces.
It functions the same as the [Triangulate](../../../meshes/editing/face/triangulate_faces.xhtml#bpy-ops-mesh-quads-convert-to-tris) tool in Edit Mode.
user: Explain Warp Modifier in complete detail according to the official Blender documentation.

assistant: # Warp Modifier

The *Warp* modifier can be used to warp parts of a mesh to a new location in
a very flexible way, by using two objects to select the “from” and “to” regions.

[image reference removed]

A Warp modifier applied to a grid mesh.

This modifier is a bit tricky to understand at first.
It requires two points, specified by the two target objects’ origins.
The “from” point designates a point in space that is pulled toward the “to” point.
It is akin to using
the [Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml) in Edit Mode.
user: Show practical ways to work with Is Edge Smooth Node in a Blender add-on or script – include code.

assistant: # Is Edge Smooth Node

[image reference removed]

The *Is Edge Smooth* node outputs true for each edge of the mesh that is *not* marked as sharp. Otherwise, if the edge
*is* marked as sharp, then the node outputs false.
user: What is Extrude Mesh Node and how is it used in Blender Python scripting?

assistant: # Extrude Mesh Node

[image reference removed]

The *Extrude Mesh Node* generates new edges or faces on the selected geometry elements
and moves them by a certain offset.

The operations are similar to the [extrude tools](../../../meshes/editing/mesh/extrude.xhtml)
in mesh edit mode, though there are some differences. Most importantly, the node never keeps the back-faces
of the extrusion in place, they are always removed. Attribute propagation rules may also be different.
user: What is Clouds and how is it used in Blender Python scripting?

assistant: # Clouds

Clouds represent Perlin noise. In addition, each noise-based Blender texture
(with the exception of Voronoi and simple noise) has a *Noise Basis* setting that allows
the user to select which algorithm is used to generate the texture. This is often used for
Clouds, Fire, Smoke. Well-suited to be used as a Bump map, giving an overall irregularity to the material.

[image reference removed]

Clouds Texture panels.
user: Explain MeshSkinVertexLayer(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # MeshSkinVertexLayer(bpy_struct)

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

*class* bpy.types.MeshSkinVertexLayer(*bpy_struct*)
:   Per-vertex skin data for use with the Skin modifier

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

    name
    :   Name of skin layer

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Even Thickness

Solidify thickness is an approximation.
While *Even Thickness* and *High Quality Normals* should yield good results,
the final wall thickness is not guaranteed and may vary depending on the mesh topology.
Especially for vertices with more than three adjacent faces.

In order to maintain a precise wall thickness in every case, we would need to add/remove faces on
the offset shell, something this modifier does not do since this would add a lot of complexity.
The best option to preserve wall thickness is complex mode with constraints thickness mode,
but it is also not guaranteed to work perfect in every case.
user: Show practical ways to work with ThemeConsole(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeConsole(bpy_struct)

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

*class* bpy.types.ThemeConsole(*bpy_struct*)
:   Theme settings for the Console

    cursor
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    line_error
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    line_info
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    line_input
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    line_output
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

    space
    :   Settings for space

        Type:
        :   [`ThemeSpaceGeneric`](bpy.types.ThemeSpaceGeneric.html#bpy.types.ThemeSpaceGeneric "bpy.types.ThemeSpaceGeneric"), (readonly, never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Keying Sets

[image reference removed]

The Active Keying Sets data ID in the Timeline.

Keying Sets are a collection of animated properties that are used to animate
and keyframe multiple properties at the same time.
For example, pressing `K` in the 3D Viewport will bring up the available Keying Sets.
Blender will then add keyframes for whichever Keying Set is chosen.
There are some built-in Keying Sets and also custom Keying Sets called “Absolute Keying Sets”.
user: What is F and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [**F-Curve**](glossary/index.xhtml#term-F-Curve) - [F-Curve Modifiers](editors/graph_editor/fcurves/modifiers.xhtml#index-1)   - [Built-in Function Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-3)   - [Cycles Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-5)   - [Envelope Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-4)   - [Generator Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-2)   - [Limits Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-7)   - [Noise Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-6)   - [Stepped Interpolation Modifier](editors/graph_editor/fcurves/modifiers.xhtml#index-8) - [**Face**](glossary/index.xhtml#term-Face) - [**Face Loop**](glossary/index.xhtml#term-Face-Loop) - [**Face Normal**](glossary/index.xhtml#term-Face-Normal) - [**Fake User**](glossary/index.xhtml#term-Fake-User) - [**Field of View**](glossary/index.xhtml#term-Field-of-View) - [**Fireflies**](glossary/index.xhtml#term-Fireflies) - [**FK**](glossary/index.xhtml#term-FK) | - [**Focal Length**](glossary/index.xhtml#term-Focal-Length) - [Force Fields](physics/forces/force_fields/introduction.xhtml#index-0)   - [Boid](physics/forces/force_fields/types/boid.xhtml#index-0)   - [Charge](physics/forces/force_fields/types/charge.xhtml#index-0)   - [Curve Guide](physics/forces/force_fields/types/curve_guide.xhtml#index-0)   - [Drag](physics/forces/force_fields/types/drag.xhtml#index-0)   - [Fluid Force](physics/forces/force_fields/types/fluid_flow.xhtml#index-0)   - [Force](physics/forces/force_fields/types/force.xhtml#index-0)   - [Harmonic](physics/forces/force_fields/types/harmonic.xhtml#index-0)   - [Lennard-Jones](physics/forces/force_fields/types/lennard_jones.xhtml#index-0)   - [Magnetic](physics/forces/force_fields/types/magnetic.xhtml#index-0)   - [Texture](physics/forces/force_fields/types/texture.xhtml#index-0)   - [Turbulence](physics/forces/force_fields/types/turbulence.xhtml#index-0)   - [Vortex](physics/forces/force_fields/types/vortex.xhtml#index-0)   - [Wind](physics/forces/force_fields/types/wind.xhtml#index-0) - [**Forward Kinematics**](glossary/index.xhtml#term-Forward-Kinematics) - [**Frame Types**](glossary/index.xhtml#term-Frame-Types) |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Rotation
:   The [Euler](../../../../glossary/index.html#term-Euler) rotation to align.

Factor
:   Determines how much the points are rotated towards the vector.
    Zero effectively disables the node and one means that the points are aligned with the vector perfectly.

Vector
:   The direction vector that points should be rotated to.
    The vector is in the local space of the object that is being modified.
    When it is all zeros for a point, it is not rotated at all.
user: Show practical ways to work with Animation & Overrides in a Blender add-on or script – include code.

assistant: Due to current design of animation data in Blender, what is editable in overrides’ animations can
change greatly depending on whether animation data was already defined in the linked reference
data-block. Animation data is created for a datablock if it gets animated by keyframes, or
through drivers.

In general, an overrides can do much more with its animation data if no animation data exists
in its linked reference data-block.

**Keyframes (a.k.a. F-Curves)**

[Keyframed animation](../../animation/keyframes/introduction.xhtml) belongs to another data-block
(an Action one). So it is possible to assign a purely local Action data-block replacing
the one linked from the library. This will completely replace the keyframed animation
from the linked data though, and not override it in any way.

Overridden Action data-blocks only support a very limited amount of editing.
For example, an existing F-Curve can be muted, but its keyframes cannot be edited,
and no new F-Curve can be added.

**Drivers**

If the linked reference data has animation data, then its overrides only have
limited possibilities to edit the existing [drivers](../../animation/drivers/introduction.xhtml).
For example, it will be possible to change the exisitng target of a driver,
but it won’t be possible to add new drivers, or new targets to an existing driver.

If the linked reference data has no animation data, then its overrides will create a new one
when they get some drivers defined. Drivers can then be fully edited, added or removed,
just as with purely local data-blocks.

**NLA**

The [NLA editor](../../editors/nla/introduction.xhtml) data also belongs to the animation data
of a data-block. However, this data does support some greater level of editing in overrides,
including moving or resizing existing strips from the linked data, and adding new local strips.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Standard color input image.

Radius
:   Controls how much surrounding area is sampled when detecting edges.
    Larger values affect broader regions and can enhance larger features,
    while smaller values focus on fine detail.

Factor
:   Controls the intensity of the sharpening effect.
    Higher values produce stronger edge contrast but can lead to halos or artifacts if overused.

Threshold
:   Defines how different a pixel must be from its surrounding area before sharpening is applied.
    Higher values limit sharpening to more distinct edges, reducing noise enhancement.
user: Describe Property Definitions (bpy.props) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Property Definitions (bpy.props)

This module defines properties to extend Blender’s internal data. The result of these functions is used to assign properties to classes registered with Blender and can’t be used directly.
user: Show practical ways to work with API Reference Usage in a Blender add-on or script – include code.

assistant: # API Reference Usage

Blender has many interlinking data types which have an auto-generated reference API which often has the information
you need to write a script, but can be difficult to use.
This document is designed to help you understand how to use the reference API.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Domain
:   The type of geometry element to duplicate

    Point:
    :   Duplicate the points of meshes, curves, or point clouds.
        Any other elements will not be included in the output.

    Edge:
    :   Duplicate mesh edges. Faces will not be included in the output.

    Faces:
    :   Duplicate mesh faces. Each duplicated face will be separate,
        in other words they will not share edges with other faces.

    Spline:
    :   Individual curves from the input curves component will be duplicated.

    Instances:
    :   Input top-level instances will be duplicated.
user: Give a detailed overview of Drivers: syntax, arguments, return values, common patterns.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Linux, graphics drivers are usually installed as a package by your Linux distribution. Installing the latest
drivers is typically done by upgrading packages or the distribution as a whole. Some distributions provide multiple
packages for multiple drivers versions, giving you the choice to install newer versions.

AMD drivers are open source, except for OpenCL support which is available as part of their Pro drivers. Installing
packages through your Linux distribution is usually best. AMD also provides graphics drivers for download on their
website if you need the latest version.

[AMD Drivers and Support Website](https://www.amd.com/en/support)

A lot of fixes for AMD and Intel GPUs are backported into the Mesa drivers. Therefore it is recommended to install or upgrade to their latest point [releases](https://docs.mesa3d.org/relnotes.html). For certain Linux distribution versions this can be done using custom repositories. For example, using the [kisak-mesa PPA](https://launchpad.net/~kisak/+archive/ubuntu/kisak-mesa) for Ubuntu.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Manual Z-Mask

[image reference removed]

Minimum and maximum function example.

The top *Render Layers* node has a cube that is about 10 units from the camera.
The bottom *Render Layers* node has a plane that covers the left half of the view
and is 7 units from the camera.
Both are fed through their respective *Map Value* nodes to multiply the depth value by
0.05 and clamp it to [0.0, 1.0], bringing it into a suitable range for displaying it as a color.

The Minimum node selects the smallest of the two depth values at each pixel. In the left half,
it chooses the plane (because it’s closer than the cube), and in the right half,
it chooses the cube (because it’s closer than the background, which is infinitely far away).

The Maximum node selects the largest of the two depth values at each pixel. In the left half,
it chooses the cube (because it’s farther away than the plane), and in the right half,
it chooses the background (because it’s farther away than the cube).

### Using Sine Function to Pulsate

[image reference removed]

Using sine function example.

This example has a *Time* node putting out a linear sequence from 0 to 1 over the course of 101 frames.
At frame 25, the output value is 0.25.
That value is multiplied by 2 × pi (6.28) and converted to 1.0 by the Sine function,
since \(sin(2 × pi/ 4) = sin(pi/ 2) = +1.0\).

Since the sine function can output values between (-1.0 to 1.0),
the *Map Value* node scales that to 0.0 to 1.0 by taking the input (-1 to 1), adding 1
(making 0 to 2), and multiplying the result by 0.5 (thus scaling the output between 0 to 1).
The default *Color Ramp* converts those values to a gray-scale.
Thus, medium gray corresponds to a 0.0 output by the sine, black to -1.0,
and white to 1.0. As you can see, \(sin(pi/ 2) = 1.0\). Like having your own visual color calculator!
Animating this node setup provides a smooth cyclic sequence through the range of grays.

Use this function to vary, for example,
the alpha channel of an image to produce a fading in/out effect.
Alter the Z channel to move a scene in/out of focus.
Alter a color channel value to make a color “pulse”.

### Brightening (Scaling) a Channel

[image reference removed]

Scaling a channel example.

This example has a *Math (Multiply)* node increasing the luminance channel (Y)
of the image to make it brighter. Note that you should use a *Map Value node*
with min() and max() enabled to clamp the output to valid values.
With this approach, you could use a logarithmic function to make a high dynamic range image.
For this particular example,
there is also a *Brightness/Contrast node* that might give simpler control over brightness.