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

assistant: Assets can be broadly divided into two types: **primitive** and **preset** assets.
Which is which depends on the [Data-Blocks](../data_blocks.html) type.

Primitive assets are data-blocks that are either **linked or appended** to the current file.
Examples are objects, materials, and worlds. These can be dragged from the Asset Browser into
the scene (objects and worlds), or onto existing objects (materials).

Preset assets are data-blocks that are loaded and then **applied** to something or **activated**.
An example is a pose asset. When applying the pose, the data-block is loaded from its blend-file,
and then the pose is applied to the active armature. Brush assets are an example of an asset type
that is activated. They get loaded into the current file and activated for painting or sculpting,
but don’t get saved in the file.

In the future, the asset type definition will be expanded;
see [Future Development](#asset-libraries-future-development) for more info.

### Supported Assets

| Asset | Type | Description |
| --- | --- | --- |
| Material | Primitive | A [Material](../../render/materials/index.html) data-block that can be applied to objects. When dragged onto an object, it replaces the material slot. |
| Collection | Primitive | A [Collection](../../scene_layout/collections/index.html) is a group of objects that can be linked or appended into a scene. Collections maintain their internal hierarchy and can be instanced or used for modular scene composition. |
| Object | Primitive | A standard [Object](../../scene_layout/object/index.html) asset that can be dragged into the scene. It may contain mesh, curve, light, or other data. |
| Brush | Preset | A [Brush](../../sculpt_paint/brush/index.html) asset used for sculpting, texture painting, or vertex painting. When activated, it becomes the current brush but is not stored permanently in the file. |
| Node Group | Primitive | A [Node Group](../../interface/controls/nodes/groups.html) asset that can be dragged into compatible node editors such as Geometry Nodes, Shader Editor, or Compositor. Acts as a reusable building block of node logic. |
| World | Primitive | A [World](../../render/lights/world.html) asset defining ambient lighting and background. When dragged into the viewport, it replaces the current world. It can also be appended as a data-block. |
| Scene | Primitive | A full [Scene](../../scene_layout/scene/index.html) asset, including its cameras, lights, and linked objects.   - Scenes generate previews by rendering the active camera view in Solid mode.   This requires the scene to have an active camera. - Dragging a scene asset into a window (except the Asset Browser itself)   imports or links the scene and makes it the active scene in that window. |
| Pose Action | Preset | A [Pose Asset](../../animation/armatures/posing/editing/pose_library.html) based on an Action data-block. Applying it loads the pose data and applies it to the selected or active armature, updating bone transforms without permanently modifying the source action. |
user: What is Movement and how is it used in Blender Python scripting?

assistant: [image reference removed]

Boid Movement settings.

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

Allow Flight
:   Enables movement in the air.

Allow Land
:   Enables movement on land.

Allow Climbing
:   Enables climbing toward goal objects.

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

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

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

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

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

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

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

Jump Speed
:   The velocity boids achieve during jumps.

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

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

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

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

Collision Collection
:   Restricts collisions to objects within the specified collection.
    This is useful for limiting interactions to certain objects or environments.
user: How do I use Status Bar in Blender? Include parameters, examples, warnings and best practices.

assistant: # Status Bar

The Status Bar is located at the bottom of the Blender window and displays contextual information such as
keyboard shortcuts, messages, and statistical information.
The Status Bar can be hidden by disabling *Show Status Bar* in Window menu or by dragging from the top edge down.

[image reference removed]

Status Bar.
user: Provide the full official documentation entry for Visual Transform, preserving all code examples.

assistant: Apply the result of each selected object’s constraints to that object’s own transformation.
This will make the objects keep their location, rotation, and scale even if their
constraints are disabled or deleted.
user: Give a detailed overview of Creating Custom Gizmos: syntax, arguments, return values, common patterns.

assistant: Adding custom gizmos to a node group that generates or modifies geometry can make it more convenient to use.

To add a gizmo to a node group, one has to use one of the [gizmo nodes](input/gizmo/index.html#gizmo-nodes-overview).
The main aspect that makes gizmos unintuitive at first is that there is a **bidirectional dependency**:
changing the gizmo position changes the controlled value and vice versa.

The most simple custom gizmo setup is shown below.
The Linear Gizmo node adds a gizmo that is drawn in the 3D viewport.
The gizmo controls the value that is plugged into it.
When trying this, you will notice that the gizmo always jumps back to the origin while the value is still changed.
That is because the Position of the gizmo node does not depend on the value yet.

[image reference removed]

The simplest custom gizmo setup.

When the gizmo position is made dependent on the value, the gizmo works more than one would expect.
It now also works in both directions: changing the value moves the gizmo and moving the gizmo changes the value.

[image reference removed]

Simple gizmo setup where the gizmo position depends on the controlled value.

Multiple values can be plugged into the Value input of gizmo nodes at once.
In that case, all these values are modified at the same time when moving the gizmo.
Multiply or divide nodes can be used if the values should change at different rates.

The Transform output of gizmo nodes should be joined into the geometry that the gizmo controls.
This helps Blender to understand that the gizmos should be transformed together with the geometry later on.

[image reference removed]

Example showing how to add simple gizmos to the built-in [Grid](mesh/primitives/grid.html#bpy-types-geometrynodemeshgrid) node.
user: What is Active Spline and how is it used in Blender Python scripting?

assistant: # Active Spline

The *Active Spline* panel is used in Edit Mode to control properties of the currently selected spline.

Common Options

Cyclic U
:   Closes the active spline.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_active-spline_nurbs-default.png   Default NURBS curve. | ../../../_images/modeling_curves_properties_active-spline_nurbs-cyclic.png   A NURBS curve with Cyclic applied. |

Resolution U
:   Alters the [resolution](shape.html#bpy-types-curve-resolution-u)
    of each segment by changing the number of subdivisions.

Smooth
:   Use [Smooth Shading](../../meshes/editing/mesh/shading.html#modeling-meshes-editing-normals-shading) for any 3D geometry.
user: What is Mesh Sequence Cache Modifier and how is it used in Blender Python scripting?

assistant: # Mesh Sequence Cache Modifier

The Mesh Sequence Cache modifier loads data from [Alembic](../../../files/import_export/alembic.xhtml)
and [USD](../../../files/import_export/usd.xhtml) files.
It supports static meshes, but is mostly used to load animated meshes.
Despite its name, this modifier also supports curves. It also handles file sequences,
as well as meshes and curves with varying topology (like the result of fluid simulations).

When importing an [Alembic](../../../files/import_export/alembic.xhtml) or
[USD](../../../files/import_export/usd.xhtml) file,
Mesh Sequence Cache modifiers are automatically added to time-varying meshes.
For time-varying object transforms (so animation of rotation, location, or scale),
the [Transform Cache Constraint](../../../animation/constraints/transform/transform_cache.xhtml#bpy-types-transformcacheconstraint) is used.
Files other than Alembic or USD, like MDD and PC2 files, can be loaded using
the [Mesh Cache modifier](mesh_cache.xhtml).
user: Describe Dope Sheet Modes from the Blender manual or Python API, including usage steps and snippets.

assistant: The editor has several different modes that can be selected from a dropdown in the header.
The default *Dope Sheet* mode gives an overview of most types of animatable data.
For others, such as masks, you need to switch to a more specific mode.

[image reference removed]

Dope Sheet modes.

The modes are as follows:

- Dope Sheet
- [Action Editor](modes/action.html)
- [Shape Key Editor](modes/shape_key.html)
- [Grease Pencil](modes/grease_pencil.html)
- [Mask](modes/mask.html)
- Cache File: originally meant to show the baked animation data in [Alembic](../../files/import_export/alembic.html)
  files, but never implemented.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Object.soft_body`](bpy.types.Object.html#bpy.types.Object.soft_body "bpy.types.Object.soft_body") | - [`SoftBodyModifier.settings`](bpy.types.SoftBodyModifier.html#bpy.types.SoftBodyModifier.settings "bpy.types.SoftBodyModifier.settings") |
user: Explain Texture Space in complete detail according to the official Blender documentation.

assistant: Each Object can have an automatically generated UV map, these maps can be adjusted here.

See [Generated UV Properties](../meshes/uv/uv_texture_spaces.html#properties-texture-space) for more information.
user: Give a detailed overview of ThemeStyle(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ThemeStyle(bpy_struct)

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

*class* bpy.types.ThemeStyle(*bpy_struct*)
:   Theme settings for style sets

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

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

    widget
    :   Type:
        :   [`ThemeFontStyle`](bpy.types.ThemeFontStyle.html#bpy.types.ThemeFontStyle "bpy.types.ThemeFontStyle"), (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: Give a detailed overview of Display: syntax, arguments, return values, common patterns.

assistant: Resolution Scale
:   Adjusts the size of fonts and buttons relative to the automatically detected DPI.
    During typical usage, you may prefer to use zoom which is available in many parts of Blender interface.

Line Width
:   Scale of lines and points in the interface e.g. button outlines, edges and vertex points in the 3D Viewport.

    Thin, Default, Thick

Splash Screen
:   Display the [Splash Screen](../../interface/window_system/splash.html#splash) when starting Blender.

Developer Extras
:   Show settings and menu items which are intended to help developers, this includes:

    - [Operator Search](../../interface/operators.html#bpy-ops-wm-search-operator)
    - [Sequencer Cache Settings](../video_sequencer/sequencer/sidebar/cache.html)

    Button Context Menu
    :   Online Python Reference
        :   To open the Python reference manual.

        Copy Python Command
        :   To copy the expression used when pressing the button.

        Edit Source
        :   To edit Python source code that defines the button.

        Edit Translation
        :   The option to edit UI translations
            (only available when the *Manage UI translations* add-on is also enabled).

    Preferences
    :   Experimental Tab
        :   Work in progress features can be enabled here which are currently being tested.

Tooltips
:   User Tooltips
    :   When enabled, a tooltip will appear when your mouse pointer is over a control.
        This tip explains the function of what is under the pointer,
        shows the associated hotkey (if any).
        When disabled, you can still force the tooltip display by holding `Alt` then hovering the control.

    Python Tooltips
    :   Displays a property’s Python information below the tooltip.

Search – Sort by Most Recent
:   Show most recently selected items at the top of search results,
    otherwise search results are sorted alphabetically.
user: Give a detailed overview of Visual Geometry to Objects: syntax, arguments, return values, common patterns.

assistant: Creates new objects from the evaluated geometry of the active object,
including the effects of all modifiers, constraints, and instancing.

This operator is similar to [Make Instances Real](#bpy-ops-object-duplicates-make-real),
but with several key differences:

- Instanced geometry is **not** realized. Instead, shared data is preserved between objects that use it.
- The original object is **not removed or modified**,
  avoiding unintended disruptions to relationships with other objects.
- Instancing hierarchies are preserved by creating new objects
  and collections that reflect the evaluated structure.

This operator is useful for extracting visible results of geometry nodes, modifiers, or instancing setups
without permanently modifying the original scene structure.
user: What is GeometryNodeSetCurveRadius(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSetCurveRadius(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.GeometryNodeSetCurveRadius(*GeometryNode*)
:   Set the radius of the curve at each control point

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

assistant: Grid
:   The input SDF grid to be smoothed.
    Typically generated from another SDF operation such as a boolean or mesh conversion.

Iterations
:   The number of smoothing iterations to apply.
    Higher values produce a larger, smoother fillet radius but also increase computation time.
    A single iteration results in a subtle rounding, while multiple iterations
    create progressively softer surfaces.
user: How do I use Rip Vertices and Fill in Blender? Include parameters, examples, warnings and best practices.

assistant: # Rip Vertices and Fill

Rip fill works the same as the Rip tool above, but instead of leaving a hole,
it fills in the gap with geometry.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-before.png   Edges selected. | ../../../../_images/modeling_meshes_editing_vertex_rip-vertices-fill_result.png   Result of rip fill. |
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

[image reference removed]

Multi-view is a complete toolset for working with stereoscopic rendering in Blender.
It works with both the EEVEE and Cycles rendering engines.
Cycles additionally supports stereoscopic panoramic cameras.
There is support for many different stereo 3D visualization types.
user: Give a detailed overview of Open Cached Render: syntax, arguments, return values, common patterns.

assistant: Find the render cache file for the current scene and load it into the
Render Result. This way, you can restore the last render from a previous
Blender session and continue working in the Compositor without having to
render the scene again.

Note that Blender doesn’t create these cache files by default. You
have to enable [Cache Result](../../render/output/properties/output.xhtml#bpy-types-rendersettings-use-render-cache)
in the scene’s Output options and then render it at least once.
user: How do I use Performance in Blender? Include parameters, examples, warnings and best practices.

assistant: Sampling for light linking is most efficient with the [light tree](../cycles/render_settings/sampling.html#bpy-types-cyclesrendersettings-use-light-tree) enabled, where a specialized acceleration structure is built for
light linking.

When using shadow linking, renders can be slower and trace additional rays,
as direct and indirect lighting take different paths.
user: How do I use GPU Texture Utilities (gpu.texture) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GPU Texture Utilities (gpu.texture)

This module provides utilities for textures.

gpu.texture.from_image(*image*)
:   Get GPUTexture corresponding to an Image data-block. The GPUTexture memory is shared with Blender.
    Note: Colors read from the texture will be in scene linear color space and have premultiplied or straight alpha matching the image alpha mode.

    Parameters:
    :   **image** ([`bpy.types.Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image")) – The Image data-block.

    Returns:
    :   The GPUTexture used by the image.

    Return type:
    :   [`gpu.types.GPUTexture`](gpu.types.html#gpu.types.GPUTexture "gpu.types.GPUTexture")
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |  |
| --- | --- | --- |
| <../../../_images/modeling_modifiers_deform_smooth_mesh-before.png>   Mesh before smoothing. | <../../../_images/modeling_modifiers_deform_smooth_mesh-one-iteration.png>   Mesh after one smoothing iteration. | <../../../_images/modeling_modifiers_deform_smooth_mesh-ten-iterations.png>   Mesh after ten smoothing iterations. |
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: A horizontal strip at the top or bottom of the editor (similar to the header)
containing settings for the currently selected tool. Just like the header,
it can be hidden and moved through its context menu.
user: How do I use Brush Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Mode
:   Defines how Color Attributes affect to the strokes.

    Stroke and Fill:
    :   Color Attributes affects both the Stroke and Fill materials.

    Stroke:
    :   Color Attributes affects the Stroke material only.

    Fill:
    :   Color Attributes affects the Fill material only.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Curves.curve_offset_data`](bpy.types.Curves.html#bpy.types.Curves.curve_offset_data "bpy.types.Curves.curve_offset_data") - [`GreasePencilDrawing.curve_offsets`](bpy.types.GreasePencilDrawing.html#bpy.types.GreasePencilDrawing.curve_offsets "bpy.types.GreasePencilDrawing.curve_offsets") | - [`IntAttribute.data`](bpy.types.IntAttribute.html#bpy.types.IntAttribute.data "bpy.types.IntAttribute.data") |
user: What is Sphere Selection Node and how is it used in Blender Python scripting?

assistant: # Sphere Selection Node

[image reference removed]

The *Sphere Selection* node creates a selection of elements that lie within a defined spherical region.
It can be used to isolate points, faces, or instances inside or near a sphere, making it useful for
localized effects, falloffs, or region-based operations.
user: Describe Vertex Groups for Bones from the Blender manual or Python API, including usage steps and snippets.

assistant: This is one of the main uses of weight painting. While you can have Blender
generate the weights automatically (see the
[skinning section](../../animation/armatures/skinning/index.xhtml)),
you may want to tweak them or even create them from scratch,
especially around joints.

The process is as follows:

1. Select the armature and bring it into *Pose Mode* by pressing `Ctrl`-`Tab`.
2. Make sure that Edit ‣ Lock Object Modes is unchecked
   in the topbar.
3. Select the mesh and bring it into *Weight Paint Mode*.
4. Make sure that *Bone Selection* is checked in the 3D Viewport’s header.
5. Select a bone using `Alt`-`LMB` (or `Shift`-`Ctrl`-`LMB`).
   This will activate the bone’s vertex group and display its current weights on the mesh.
6. Paint weights for the bone using `LMB`.

If a bone doesn’t have a vertex group yet when you start painting,
Blender will create one automatically.

If you have a symmetrical mesh and a symmetrical armature, you can use
[Mirror Vertex Groups](tool_settings/symmetry.xhtml#bpy-types-mesh-use-mirror-vertex-groups)
to automatically create vertex groups and weights for the other side.
user: Show practical ways to work with ShaderNodeVolumeAbsorption(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeVolumeAbsorption(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.ShaderNodeVolumeAbsorption(*ShaderNode*)
:   Absorb light as it passes through the volume

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

assistant: Real-world effects such as scattering in clouds or subsurface scattering require many
scattering bounces. However, unbiased rendering of such effects can be noisy, so by default
the number of bounces is zero in Cycles, and no support is available in EEVEE.
The effect you get when rendering with zero volume bounces is what is known as
“single scattering”, the effect from more bounces is “multiple scattering”.

For rendering materials like skin or milk that require multiple scattering,
subsurface scattering is more efficient and easier to control. Particularly the random walk
method can accurately render such materials.

For materials such as clouds or smoke that do not have a well-defined surface,
volume rendering is required. These look best with many scattering bounces,
but in practice one might have to limit the number of bounces to keep render times acceptable.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: Here is and example of using a texture and the mapping curve to generate weights used by
the [Wave](../deform/wave.html) modifier.

Texture channel variations.

|  |  |  |
| --- | --- | --- |
| <../../../_images/modeling_modifiers_modify_weight-mix_intensity.jpg>   Using intensity. | <../../../_images/modeling_modifiers_modify_weight-mix_red.jpg>   Using Red. | <../../../_images/modeling_modifiers_modify_weight-mix_saturation.jpg>   Using Saturation. |

Custom mapping curve with a Vertex Weight Edit modifier.

|  |  |  |
| --- | --- | --- |
| <../../../_images/modeling_modifiers_modify_weight-mix_map-curve.png>   A customized mapping curve. | <../../../_images/modeling_modifiers_modify_weight-mix_red.jpg>   Custom Mapping disabled. | <../../../_images/modeling_modifiers_modify_weight-mix_red-map.jpg>   Custom Mapping enabled. |

[The blend-file](https://archive.blender.org/wiki/2015/index.php/File:ManModifiersWeightVGroupEx.blend),
TEST_4 scene.
user: Give a detailed overview of Field Weights: syntax, arguments, return values, common patterns.

assistant: # Field Weights

These settings determine how much gravity and
[Force Fields](../../../forces/force_fields/index.xhtml) affect the fluid.

Effector Collection
:   When set, fluid can only be influenced by force fields in the specified collection.

Gravity
:   How much the fluid is affected by Gravity.

All
:   Overall influence of all force fields.

The other settings determine how much influence individual force field types have.
user: Provide the full official documentation entry for GeometryNodeImportPLY(GeometryNode), preserving all code examples.

assistant: # GeometryNodeImportPLY(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.GeometryNodeImportPLY(*GeometryNode*)
:   Import a point cloud from a PLY file

    *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: Describe VolumeGrids(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # VolumeGrids(bpy_struct)

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

*class* bpy.types.VolumeGrids(*bpy_struct*)
:   3D volume grids

    active_index
    :   Index of active volume grid

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

    error_message
    :   If loading grids failed, error message with details

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

    frame
    :   Frame number that volume grids will be loaded at, based on scene time and volume parameters

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

    frame_filepath
    :   Volume file used for loading the volume at the current frame. Empty if the volume has not be loaded or the frame only exists in memory.

        Type:
        :   string, default “”, (readonly, never None, blend relative `//` prefix supported)

    is_loaded
    :   List of grids and metadata are loaded in memory

        Type:
        :   boolean, default False, (readonly)

    load()
    :   Load list of grids and metadata from file

        Returns:
        :   True if grid list was successfully loaded

        Return type:
        :   boolean

    unload()
    :   Unload all grid and voxel data from memory

    save(*filepath*)
    :   Save grids and metadata to file

        Parameters:
        :   **filepath** (*string**,* *(**never None**)*) – File path to save to

        Returns:
        :   True if grid list was successfully loaded

        Return type:
        :   boolean

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

assistant: Track
:   See [Track Motion](../editing/track.html#bpy-ops-clip-track-markers).

Clear
:   See [Before](../editing/track.html#bpy-ops-clip-clear-track-path).

Refine
:   See [Refine](../editing/track.html#bpy-ops-clip-refine-markers).

Merge
:   Join Tracks
    :   See [Join Tracks](../editing/track.html#bpy-ops-clip-join-tracks).
user: Describe NodeTreeInterfaceSocketVectorEuler2D(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketVectorEuler2D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorEuler2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

assistant: # FBX

The *FBX* (Filmbox) format is widely used for exchanging 3D data between applications,
especially for animated characters and complex scene data. It is supported by software
such as Autodesk Maya, 3ds Max, Cinema 4D, and game engines like Unity and Unreal Engine.

The exporter can bake mesh modifiers and animation into the FBX so the final result looks the same as in Blender.
user: What is BrushCapabilitiesVertexPaint(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BrushCapabilitiesVertexPaint(bpy_struct)

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

*class* bpy.types.BrushCapabilitiesVertexPaint(*bpy_struct*)
:   Read-only indications of supported operations

    has_color
    :   Type:
        :   boolean, default False, (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: How do I use CompositorNodeDespeckle(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeDespeckle(CompositorNode)

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

*class* bpy.types.CompositorNodeDespeckle(*CompositorNode*)
:   Smooth areas of an image in which noise is noticeable, while leaving complex areas untouched

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

    update()

    *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 Import/Export SVG as Grease Pencil in complete detail according to the official Blender documentation.

assistant: # Import/Export SVG as Grease Pencil

The Scalable Vector Graphics (SVG) format is used for interchanging vector-based illustrations between applications
and is supported by vector graphics editors such as Inkscape and modern browsers, among others.
user: Explain Notes in complete detail according to the official Blender documentation.

assistant: Iterations
:   The filter can be applied multiple times by chaining the node multiple times.
    This chaining can produce more flat filtering.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_filter_kuwahara-node_original.webp   Original. | ../../../_images/compositing_types_filter_kuwahara-node_iterations1.webp   Iterations: 1. |
    | ../../../_images/compositing_types_filter_kuwahara-node_iterations2.webp   Iterations: 2. | ../../../_images/compositing_types_filter_kuwahara-node_iterations3.webp   Iterations: 3. |

Performance
:   The filter can be expensive to compute for high size input and high resolution
    images. To improve performance, consider scaling down the image, applying the
    filter, then scaling it up again. This can work well because the filter
    already attenuates low frequency details.
user: Show practical ways to work with Instance on Points Node in a Blender add-on or script – include code.

assistant: # Instance on Points Node

[image reference removed]

The *Instance on Points* node adds a reference to a geometry to each of the points present
in the input geometry. Instances are a fast way to add the same geometry to a scene many times
without duplicating the underlying data. The node works on any geometry type
with a *Point* domain, including meshes, point clouds, and curve control points.

Any attributes on the points from the *Geometry* input will be available on the instance
domain of the generated instances.
user: Give a detailed overview of Alpha: syntax, arguments, return values, common patterns.

assistant: # Alpha

In this tab you control the alpha (transparency) of your strokes.

[[image reference removed]](../../../../_images/render_freestyle_parameter-editor_line-style_alpha_tab.png)

Line Style: Alpha.

Base Transparency
:   The base alpha for this line style.
user: What is ShaderNodeSubsurfaceScattering(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeSubsurfaceScattering(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.ShaderNodeSubsurfaceScattering(*ShaderNode*)
:   Subsurface multiple scattering shader to simulate light entering the surface and bouncing internally.
    Typically used for materials such as skin, wax, marble or milk

    falloff
    :   Method for rendering subsurface scattering

        - `BURLEY`
          Christensen-Burley – Approximation to physically based volume scattering.
        - `RANDOM_WALK`
          Random Walk – Volumetric approximation to physically based volume scattering, using the scattering radius as specified.
        - `RANDOM_WALK_SKIN`
          Random Walk (Skin) – Volumetric approximation to physically based volume scattering, with scattering radius automatically adjusted to match color textures. Designed for skin shading..

        Type:
        :   enum in [`'BURLEY'`, `'RANDOM_WALK'`, `'RANDOM_WALK_SKIN'`], default `'BURLEY'`

    *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 Path Tracing, preserving all code examples.

assistant: Cycles uses path tracing with next event estimation,
which is not good at rendering all types of light effects, like caustics,
but has the advantage of being able to render more detailed and
larger scenes compared to some other rendering algorithms.
This is because we do not need to store,
for example, a photon map in memory,
and because we can keep rays relatively coherent to use an on-demand image cache,
compared to e.g. bidirectional path tracing.

[image reference removed]

We do the inverse of what reality does,
tracing light rays from the camera into the scene and onto lights,
rather than from the light sources into the scene and then into the camera.
This has the advantage that we do not waste light rays that will not end up in the camera,
but also means that it is difficult to find some light paths that may contribute a lot.
Light rays will be sent either according to the surface BSDF,
or in the direction of known light sources.