PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Fillet Curve Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Fillet Curve Node

[image reference removed]

The *Fillet Curve* rounds corners on curve control points, similar to the effect of
the [Bevel Modifier](../../../modifiers/generate/bevel.xhtml) on a 2D mesh.
However, a key difference is that the rounded portions created by the Fillet Curve node
are always portions of a circle.
user: Give a detailed overview of LibraryWeakReference(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # LibraryWeakReference(bpy_struct)

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

*class* bpy.types.LibraryWeakReference(*bpy_struct*)
:   Read-only external reference to a linked data-block and its library file

    filepath
    :   Path to the library .blend file

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

    id_name
    :   Full ID name in the library .blend file (including the two leading ‘id type’ chars)

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

assistant: Search Add-ons
:   Blender comes with some preinstalled Add-ons already, ready to be enabled.
    But you can also add your own, or any interesting ones you find on the web.

Enabled Add-ons Only
:   Shows only enabled add-ons for the current Category.

Add-on Tags
:   Add-ons are assigned categories by what areas of Blender they affect.
user: How do I use Separate Spherical Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Separate Spherical Node

[image reference removed]

The *Separate Spherical* node converts a vector from Cartesian coordinates (X, Y, Z)
into spherical coordinates (R, Φ, Θ) and outputs each component separately.
It is the inverse of the [Combine Spherical](../../../../modeling/geometry_nodes/utilities/vector/combine_spherical.xhtml) node.

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: How do I use Sample Nearest Surface Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sample Nearest Surface Node

[image reference removed]

The *Sample Nearest Surface* node finds values at the closest points on
the surface of a source mesh geometry. Non-face attributes are interpolated
across the surface.

This node is similar to the [Geometry Proximity Node](../../geometry/sample/geometry_proximity.xhtml),
but it gives the value of any attribute at the closest surface point, not just its position.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.volume`](bpy.context.html#bpy.context.volume "bpy.context.volume") - [`BlendData.volumes`](bpy.types.BlendData.html#bpy.types.BlendData.volumes "bpy.types.BlendData.volumes") | - [`BlendDataVolumes.new`](bpy.types.BlendDataVolumes.html#bpy.types.BlendDataVolumes.new "bpy.types.BlendDataVolumes.new") - [`BlendDataVolumes.remove`](bpy.types.BlendDataVolumes.html#bpy.types.BlendDataVolumes.remove "bpy.types.BlendDataVolumes.remove") |
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Each tool has the following settings to change how the unmasked mesh will be transformed.

Transform Mode
:   How the transformation is going to be applied to the target.

    All Vertices:
    :   Applies the transformation to all vertices in the mesh.

    Elastic:
    :   Applies the transformation while dynamically simulating elasticity.
        Instead of applying this to all vertices, it uses the radius of the cursor as the area of effect.
user: Describe How to Create Extensions from the Blender manual or Python API, including usage steps and snippets.

assistant: # How to Create Extensions

Creating an extension takes only a few steps:

1. Open the directory containing the add-on code or theme file.
2. Add a [blender_manifest.toml](#manifest) file with all the required meta-data `(name, maintainer, ...)`.
3. Use the [Blender command-line tool](../command_line/extension_arguments.html#command-line-args-extension-build) to build the extension .zip file.

How to publish to the [Blender Extensions Platform](https://extensions.blender.org):

- [Install from Disk](../../editors/preferences/extensions.html#prefs-extensions-install) to test if everything is working well.
- [Upload the .zip file](https://extensions.blender.org/submit/) (this step requires Blender ID).

The extension will be held for [review](https://extensions.blender.org/approval-queue/),
and published once the moderation team approves it.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Clamp To constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The Curve object to snap to.

Main Axis
:   The axis for determining the constraint owner’s coordinate and the Curve’s minimum/maximum
    coordinates.

Cyclic
:   When disabled, the constraint owner will stop at the start/end of the Curve when it leaves
    the range of the Curve’s bounding box. When enabled, it will jump to the opposite side
    and begin another run along the Curve.

    This option is mainly useful for Curves that are also [cyclic](../../../modeling/curves/editing/curve.xhtml#bpy-ops-curve-cyclic-toggle)
    (closed).

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the object.
user: What is Displace Node and how is it used in Blender Python scripting?

assistant: # Displace Node

[image reference removed]

The *Displace Node* displaces the pixel position based on an input vector.

This node could be used to model phenomena, like hot air distortion,
refractions of uneven glass or for surreal video effects.
user: Explain Cursor in complete detail according to the official Blender documentation.

assistant: # Cursor

[image reference removed]

Cursor options.

While painting or sculpting a special cursor is shown to display information about the active brush.
The cursor is shown as a circle in the 3D Viewport, the radius of the circle matches the size of the brush.

The cursor can be disabled by toggling the checkbox in the panel’s header.

Cursor Color
:   Set the color of the brush ring while performing an add/positive stroke.

Inverse Color
:   In some paint/sculpt modes the brush can be negative and subtract information from the paint target;
    these brushes can be given a separate color.

Opacity Options
:   Depending on the paint or sculpt mode different overlays are shown within the cursor
    to give information on how the brush is textured.
    This is most commonly used to show the brush falloff with a gradient from the circle center to the perimeter.

    Alpha
    :   You can change the amount of transparency used
        when showing the texture using the slider.

    Override Overlay
    :   Allows you to turn off the viewport overlay during strokes.

    / Use Cursor Overlay
    :   Toggles whether to show or hide the given brush texture overlay.
user: What is Cleanup and how is it used in Blender Python scripting?

assistant: This panel contains operators and their settings which are needed to clean up bad tracks:
tracks which are not tracked long enough or which failed to reconstruct accurately.

Frames
:   Tracks or tracked segments shorter than this number of frames will be removed.

Error
:   Tracks which has reprojection error higher than this value will be removed.

Type
:   Several actions can be performed for bad tracks:

    Select:
    :   They can simply be selected.

    Delete Track:
    :   The whole track can be deleted.

    Delete Segments:
    :   Bad segments of tracked sequence can be removed.

Clean Tracks
:   See [Clean Tracks](../editing/track.xhtml#bpy-ops-clip-clean-tracks).

Filter Tracks
:   See [Filter Tracks](../editing/track.xhtml#bpy-ops-clip-filter-tracks).
user: Provide the full official documentation entry for Split Edges Node, preserving all code examples.

assistant: # Split Edges Node

[image reference removed]

Like the [Edge Split Modifier](../../../modifiers/generate/edge_split.xhtml), the *Split Edges* node splits and duplicates edges
within a mesh, breaking ‘links’ between faces around those split edges.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`WorkSpace.owner_ids`](bpy.types.WorkSpace.html#bpy.types.WorkSpace.owner_ids "bpy.types.WorkSpace.owner_ids") - [`wmOwnerIDs.new`](bpy.types.wmOwnerIDs.html#bpy.types.wmOwnerIDs.new "bpy.types.wmOwnerIDs.new") | - [`wmOwnerIDs.remove`](bpy.types.wmOwnerIDs.html#bpy.types.wmOwnerIDs.remove "bpy.types.wmOwnerIDs.remove") |
user: Describe CompositorNodeRLayers(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeRLayers(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.CompositorNodeRLayers(*CompositorNode*)
:   Input render passes from a scene render

    layer
    :   Type:
        :   enum in [`'PLACEHOLDER'`], default `'PLACEHOLDER'`

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

    *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: Give a detailed overview of GeometryNodeSplineLength(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeSplineLength(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.GeometryNodeSplineLength(*GeometryNode*)
:   Retrieve the total length of each spline, as a distance or as a number of points

    *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 Material Index Node, preserving all code examples.

assistant: # Material Index Node

[image reference removed]

The *Material Index* node outputs which material in the list of materials of the geometry
each element corresponds to. Currently the node supports mesh data, where `material_index`
is a built-in attribute on faces.

The node to set this data is
the [Set Material Index](set_material_index.xhtml) node.
user: Describe Volume from the Blender manual or Python API, including usage steps and snippets.

assistant: Sampling Method
:   Distance:
    :   For dense volumes lit from far away *Distance* sampling is usually more efficient.

    Equiangular:
    :   If you have got a light inside or near the volume then *equiangular* sampling is better.

    Multiple Importance:
    :   If you have a combination of both, then the multiple importance sampling will be better.

Interpolation
:   Interpolation method to use for the volume objects and smoke simulation grids.

    Linear:
    :   Simple interpolation which gives good results for thin volumes.

    Cubic:
    :   Smoothed high-quality interpolation needed for more dense volumes, but slower.

Step Rate Biased
:   Adjust distance between volume shader samples for volume shaders.
    This is typically used to reduce the step size for procedural shaders that add more detail
    with procedural textures, when it is not captured by the default step size.
    Only enabled when Render ‣ Volumes ‣ Biased is enabled.
    See [Volume Render Settings](render_settings/volumes.xhtml) for more information.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`CompositorNodeOutputFile.format`](bpy.types.CompositorNodeOutputFile.html#bpy.types.CompositorNodeOutputFile.format "bpy.types.CompositorNodeOutputFile.format") - [`NodeCompositorFileOutputItem.format`](bpy.types.NodeCompositorFileOutputItem.html#bpy.types.NodeCompositorFileOutputItem.format "bpy.types.NodeCompositorFileOutputItem.format") - [`BakeSettings.image_settings`](bpy.types.BakeSettings.html#bpy.types.BakeSettings.image_settings "bpy.types.BakeSettings.image_settings") | - [`RenderSettings.image_settings`](bpy.types.RenderSettings.html#bpy.types.RenderSettings.image_settings "bpy.types.RenderSettings.image_settings") - [`UILayout.template_image_settings`](bpy.types.UILayout.html#bpy.types.UILayout.template_image_settings "bpy.types.UILayout.template_image_settings") - [`UILayout.template_image_views`](bpy.types.UILayout.html#bpy.types.UILayout.template_image_views "bpy.types.UILayout.template_image_views") |
user: What is Example and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_properties_bendy-bones_b-bones-1.png   Bones with just one segment in Edit Mode. | ../../../../_images/animation_armatures_bones_properties_bendy-bones_b-bones-2.png   The Bézier curve superposed to the chain, with its handles placed at bones’ joints. |
| ../../../../_images/animation_armatures_bones_properties_bendy-bones_b-bones-3.png   The same armature in Object Mode. |  |

In Fig. [Bones with just one segment in Edit Mode.](#fig-rig-bone-intro-bbone) we connected three bones,
each one made of five segments.

Look at Fig. [The same armature in Object Mode.](#fig-rig-bone-intro-same),
we can see how the bones’ segments smoothly “blend” into each other, even for roll.

[image reference removed]

An armature in Pose Mode, B-Bone visualization: Bone.003 has one segment,
Bone.004 has four, and Bone.005 has sixteen.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Outer Mask
:   A mask representing the outside shape, which will fade from black at its edges
    to white at the *Inner Mask*.

Inner Mask
:   A mask representing the inside shape, which will be fully white.

Images Edges
:   The edges of the image that intersects the outer mask will be considered edges
    of the outer mask. Otherwise, the outer mask will be considered open-ended.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_matte_double-edge-mask_in.png   Disabled. | ../../../_images/compositing_types_matte_double-edge-mask_bleed.png   Enabled. |

Only Inside Outer
:   Only edges of the inner mask that lie inside the outer mask will be considered.
    Otherwise, all edges of the inner mask will be considered.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_matte_double-edge-mask_all.png   Disabled. | ../../../_images/compositing_types_matte_double-edge-mask_adjacent.png   Enabled. |
user: Explain Mirror Modifier in complete detail according to the official Blender documentation.

assistant: # Mirror Modifier

The *Mirror* modifier mirrors the strokes along its local X, Y and/or Z axes, across the [Object Origin](../../../glossary/index.html#term-Object-Origin).
It can also use another object as the mirror center, then use that object’s local axes instead of its own.
user: Provide the full official documentation entry for Rigid Body World, preserving all code examples.

assistant: # Rigid Body World

The *Rigid Body World* is a group of rigid body objects,
which holds settings that apply to all rigid bodies in this simulation.

When you add rigid body physics to an object,
primary there is created a group of objects with default “RigidBodyWorld” name.
Rigid body objects automatically are added to this group when you add rigid body physics for them.
You can create several Rigid Body World [Collections](../../scene_layout/collections/collections.xhtml)
and allocate the rigid body objects with the [Collections panel](../../scene_layout/collections/collections.xhtml#scene-layout-collections-collections-panel).

Rigid body objects and constraints are only taken into account by the simulation
if they are in the collection specified in the *Collection* field of the *Rigid Body World* panel in the *Scene* tab.
user: What is SpreadsheetRowFilter(bpy_struct) and how is it used in Blender Python scripting?

assistant: # SpreadsheetRowFilter(bpy_struct)

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

*class* bpy.types.SpreadsheetRowFilter(*bpy_struct*)
:   column_name
    :   Type:
        :   string, default “”, (never None)

    enabled
    :   Type:
        :   boolean, default False

    operation
    :   Type:
        :   enum in [`'EQUAL'`, `'GREATER'`, `'LESS'`], default `'EQUAL'`

    show_expanded
    :   Type:
        :   boolean, default False

    threshold
    :   How close float values need to be to be equal

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

    value_boolean
    :   Type:
        :   boolean, default False

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

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

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

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

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

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

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

    value_int8
    :   Type:
        :   int in [-128, 127], default 0

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

assistant: ### Baking

Baking converts high-resolution geometry details, such as sculpted displacement or surface normals,
into 2D texture maps. These maps can then be applied to a lower-resolution mesh to reproduce
the appearance of fine surface detail without the performance cost of dense geometry.

This process is essential for workflows where high-resolution sculpting data is transferred to
low-resolution meshes for rendering or game engines.

To generate a normal or displacement map, use the
[Bake from Multires](../../../render/cycles/baking.html#bpy-types-rendersettings-use-bake-multires) option in the Render panel.
This feature compares two resolution levels of the Multiresolution modifier:

- **Viewport Levels:** Used as the *low-resolution* base mesh.
- **Render Levels:** Used as the *high-resolution* detail mesh.

The difference between these two levels is baked into a texture map.

#### Bake Types

The *Bake Type* determines what kind of surface information is extracted from the Multiresolution modifier.

- **Normals:**
  Bakes surface normal direction differences between the base and detailed levels.
  The resulting normal map encodes lighting information that reproduces fine sculpted detail
  in shading without modifying the actual geometry.
  Ideal for use with normal-mapped materials in Cycles, Eevee, and real-time engines.
- **Displacement:**
  Bakes height differences between the base and high-resolution mesh as a grayscale image.
  Lighter areas represent raised regions and darker areas represent recessed areas.
  This map can be used for *true* displacement in render engines or for parallax/height-based shading.
- **Vector Displacement:**
  Bakes 3D displacement vectors representing the full spatial offset from the base to the detailed surface.
  Unlike regular displacement, this method can capture overhangs and non-vertical displacements,
  providing a more accurate representation of complex sculpted details.

  The resulting texture encodes XYZ displacement in the RGB color channels.
user: Give a detailed overview of Cryptomatte: syntax, arguments, return values, common patterns.

assistant: Cryptomatte is an image standard to efficiently create masks for specific objects or materials.
Its purpose is the same as the *Object Index* and *Material Index* passes,
but it has several advantages: it’s easier to set up, can be used with other
compositing software than Blender, and supports multiple objects per pixel.
Specifically, it works with transparency, as well as motion blur and depth of field
when using Cycles.

Object
:   Render cryptomatte passes for isolating objects.

Material
:   Render cryptomatte passes for isolating materials.

Asset
:   Render cryptomatte passes for isolating groups of objects with
    the same [parent](../../scene_layout/object/editing/parent.html).
    This option is not related to Blender’s
    [asset](../../files/asset_libraries/introduction.html) feature.

Levels
:   The maximum number of objects to be distinguished per pixel.
    The Render Layers node will output half this many Cryptomatte images,
    named (for example) *CryptoObject00*, *CryptoObject01* and so on –
    the reason being that one Cryptomatte image can reference two objects per pixel.

    The first image references, for each pixel, the two objects that contribute
    the most to that pixel’s color. The next image references the next two objects,
    and so on.
user: Give a detailed overview of Slice: syntax, arguments, return values, common patterns.

assistant: Renders only a single 2D section of the domain object.

Axis
:   Auto:
    :   Adjust slice direction according to the view direction.

    X/Y/Z:
    :   Slice along the X/Y/Z axis.

Position
:   Position of the slice relative to the length of the respective domain side.

Gridlines Closest Interpolation Only
:   Display gridlines to differentiate the underlying cells in the current slice of the fluid domain.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Vector
:   3D coordinate that’s projected onto the 2D image using the selected *Projection* method.
    The node then outputs the color and alpha at this projected point.

    This slot is usually connected to an output of the [Texture Coordinate Node](../input/texture_coordinate.xhtml).
    If left unconnected, the coordinate is taken from the object’s active UV map (with Z = 0).
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`SpaceFileBrowser.params`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.params "bpy.types.SpaceFileBrowser.params") | - [`UILayout.template_file_select_path`](bpy.types.UILayout.html#bpy.types.UILayout.template_file_select_path "bpy.types.UILayout.template_file_select_path") |
user: How do I use Point Cloud in Blender? Include parameters, examples, warnings and best practices.

assistant: # Point Cloud

[Point clouds](../../glossary/index.html#term-Point-Cloud) are a type of object used to represent
large numbers of individual points in 3D space.
They are particularly useful for visualizing 3D scan data, particle simulations,
or sparse datasets where a surface mesh is unnecessary or impractical.

Each point in a point cloud can store data using *Attributes*
that define properties such as position, color, and more.
Future updates may expand support to include simulation systems like particles.

[image reference removed]

Example of a monkey object represented as a point cloud.
user: Give a detailed overview of ShaderNodeUVMap(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeUVMap(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.ShaderNodeUVMap(*ShaderNode*)
:   Retrieve a UV map from the geometry, or the default fallback if none is specified

    from_instancer
    :   Use the parent of the instance object if possible

        Type:
        :   boolean, default False

    uv_map
    :   UV coordinates to be used for mapping

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Laplacian Deform modifier.

Repeat
:   How many iterations to do to improve the found solution.
    The objective is to find the rotation of the differential coordinates
    preserving the best possible geometric details.
    Details are retained better if more iterations are used,
    however, it will take longer to calculate.

    Deform horse example
    [blend-file](https://archive.blender.org/wiki/2015/uploads/a/a2/Apinzonf_Deform_Horse_example1.blend).

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/modeling_modifiers_deform_laplacian-deform_cactus09.png   Original Model. | ../../../_images/modeling_modifiers_deform_laplacian-deform_cactus-repeat1.png   Repeat: 1. | ../../../_images/modeling_modifiers_deform_laplacian-deform_cactus-repeat2.png   Repeat: 2. | ../../../_images/modeling_modifiers_deform_laplacian-deform_cactus-repeat5.png   Repeat: 5. |
    | ../../../_images/modeling_modifiers_deform_laplacian-deform_horse-repeat0.jpg   Original Model. | ../../../_images/modeling_modifiers_deform_laplacian-deform_horse-repeat1.jpg   Repeat: 1. | ../../../_images/modeling_modifiers_deform_laplacian-deform_horse-repeat2.jpg   Repeat: 2. | ../../../_images/modeling_modifiers_deform_laplacian-deform_horse-repeat10.jpg   Repeat: 10. |

Anchor Weights
:   The group of vertices that the user will use to transform the model.
    The weight of each vertex does not affect the behavior of the modifier,
    the method only takes into account vertices with weight greater than 0.

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

        The setting reverses the weight values of the group.

Bind
:   The *Bind* button is what tells the *Laplacian Deform* modifier to actually capture the geometry details
    of the object, so that altering the anchor vertices actually alters the shape of the deformed object.

Unbind
:   After binding the modifier, you may later decide to make changes to the *Anchors Vertex Group*.
    To do so you will first need to *Unbind* the modifier before binding it again.
user: What is About Blender and how is it used in Blender Python scripting?

assistant: # About Blender

Blender is the free and open-source 3D creation suite. It supports the entirety of the 3D pipeline: modeling, rigging,
animation, simulation, rendering, compositing, motion tracking and video editing.

Blender provides a consistent experience across Linux, macOS, and Windows operating systems via OpenGL.

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

assistant: |  |  |
| --- | --- |
| - [`EffectStrip.proxy`](bpy.types.EffectStrip.html#bpy.types.EffectStrip.proxy "bpy.types.EffectStrip.proxy") - [`ImageStrip.proxy`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.proxy "bpy.types.ImageStrip.proxy") - [`MetaStrip.proxy`](bpy.types.MetaStrip.html#bpy.types.MetaStrip.proxy "bpy.types.MetaStrip.proxy") | - [`MovieStrip.proxy`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.proxy "bpy.types.MovieStrip.proxy") - [`SceneStrip.proxy`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.proxy "bpy.types.SceneStrip.proxy") |
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Instances
:   Standard geometry input.

Selection
:   The instances used to generate points. True values mean a point is created for the instance,
    false values mean the instance is skipped.

Position
:   Overrides the default position of generated point.

Radius
:   Controls the radius of the result points.
user: Describe In Edit Mode from the Blender manual or Python API, including usage steps and snippets.

assistant: The pivot point becomes the center of the bounding box around the selected mesh elements.

[image reference removed]

The effects of rotation in different mesh selection modes.
The pivot point is shown by a yellow circle.

Median Point may again give a different result.

[image reference removed]

Difference between “Bounding Box Center” (left) and “Median Point” (right).
user: How do I use Extensions Tags in Blender? Include parameters, examples, warnings and best practices.

assistant: # Extensions Tags

A different set of tags is available for the different extensions types.
This is the list of the tags currently supported by the [Blender Extensions Platform](https://extensions.blender.org/):
user: Explain Keyframe Paste Offset Items in complete detail according to the official Blender documentation.

assistant: # Keyframe Paste Offset Items

START:
:   Frame Start.

    Paste keys starting at current frame.

END:
:   Frame End.

    Paste keys ending at current frame.

RELATIVE:
:   Frame Relative.

    Paste keys relative to the current frame when copying.

NONE:
:   No Offset.

    Paste keys from original time.
user: Provide the full official documentation entry for GeometryNodeGeometryToInstance(GeometryNode), preserving all code examples.

assistant: # GeometryNodeGeometryToInstance(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.GeometryNodeGeometryToInstance(*GeometryNode*)
:   Convert each input geometry into an instance, which can be much faster than the Join Geometry node when the inputs are large

    *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 Clipping Region, preserving all code examples.

assistant: Allows you to define a clipping region to limit the 3D Viewport display to a portion of 3D space.
It can assist in the process of working with complex models and scenes.

Once activated, you have to draw a rectangle with the mouse.
It becomes a clipping volume of four planes:

- A right-angled [parallelepiped](https://en.wikipedia.org/wiki/Parallelepiped)
  (of infinite length) if your view is orthographic.
- A rectangular-based pyramid (of infinite height) if your view is in perspective.

Once clipping is used, you will only see what’s inside the volume you defined.
Tools such as paint, sculpt, selection, transform snapping, etc.
will also ignore geometry outside the clipping bounds.

To delete this clipping, press `Alt`-`B` again.

### Example

Region/Volume clipping.

|  |  |  |
| --- | --- | --- |
| <../../../_images/editors_3dview_navigate_regions_border1.png>   Selecting a region. | <../../../_images/editors_3dview_navigate_regions_border2.png>   Region selected. | <../../../_images/editors_3dview_navigate_regions_border3.png>   View rotated. |

The *Region/Volume clipping* image shows an example of using the clipping tool with a cube.
Start by activating the tool with `Alt`-`B`.
This will generate a dashed cross-hair cursor.
Click with the `LMB` and drag out a rectangular region.
Now clipping is applied against that region in 3D space.
Use the `MMB` to rotate
the view and you will see that only what is inside the clipping volume is visible.
All the editing tools still function as normal, but only within the clipping volume.

The dark gray area is the clipping volume itself.
Once clipping is deactivated with another `Alt`-`B`,
all of 3D space will become visible again.
user: How do I use Rendering in Blender? Include parameters, examples, warnings and best practices.

assistant: The render and output settings of the Sequencer Scene are the same as for regular scenes.
They can be found in the Output tab in the Properties editor. Note that these settings
follow the active scene in the window by default (unless there is a Scene pinned to the
properties editor).

When the active scene is different from the Sequencer Scene in the current workspace,
the “Render” menu will include separate options to render the Sequencer Scene (and not the active Scene).
user: Show practical ways to work with ShaderNodeHoldout(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeHoldout(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.ShaderNodeHoldout(*ShaderNode*)
:   Create a “hole” in the image with zero alpha transparency, which is useful for compositing.
    Note: the holdout shader can only create alpha when transparency is enabled in the film settings

    *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: How do I use GreasePencilLayerMasks(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GreasePencilLayerMasks(bpy_struct)

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

*class* bpy.types.GreasePencilLayerMasks(*bpy_struct*)
:   Collection of Grease Pencil masking layers

    active_mask_index
    :   Active index in layer mask array

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: e.bones Armature.collections Armature.collections_all Armature.display_type Armature.edit_bones Armature.is_editmode Armature.pose_position Armature.relation_line_position Armature.show_axes Armature.show_bone_colors Armature.show_bone_custom_shapes Armature.show_names Armature.use_mirror_x Armature.transform() Armature.bl_rna_get_subclass() Armature.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: What is Boidrule Type Items and how is it used in Blender Python scripting?

assistant: # Boidrule Type Items

GOAL:
:   Goal.

    Go to assigned object or loudest assigned signal source.

AVOID:
:   Avoid.

    Get away from assigned object or loudest assigned signal source.

AVOID_COLLISION:
:   Avoid Collision.

    Maneuver to avoid collisions with other boids and deflector objects in near future.

SEPARATE:
:   Separate.

    Keep from going through other boids.

FLOCK:
:   Flock.

    Move to center of neighbors and match their velocity.

FOLLOW_LEADER:
:   Follow Leader.

    Follow a boid or assigned object.

AVERAGE_SPEED:
:   Average Speed.

    Maintain speed, flight level or wander.

FIGHT:
:   Fight.

    Go to closest enemy and attack when in range.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Dimensions
:   The dimensions of the image in pixels with transformations applied.

Resolution
:   The width and height of the image in pixels.

Location
:   The position of the image in compositing space.

Rotation
:   The rotation of the image in radians, around its center.

Scale
:   The scale of the image relative to its original size in compositing space.
user: Provide the full official documentation entry for NodeGeometryViewerItems(bpy_struct), preserving all code examples.

assistant: # NodeGeometryViewerItems(bpy_struct)

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

*class* bpy.types.NodeGeometryViewerItems(*bpy_struct*)
:   Collection of viewer items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`NodeGeometryViewerItem`](bpy.types.NodeGeometryViewerItem.html#bpy.types.NodeGeometryViewerItem "bpy.types.NodeGeometryViewerItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

assistant: As the modifier is only a container its actual options are configured in the *Particle Properties* tab.
See the [Particle Systems Properties](../../../physics/particles/index.xhtml) for more information.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Image
:   Image input, to be linked to the “Combined” render pass.

Speed
:   Input for the “Vector” render pass.
    See [Cycles render passes](../../../../render/layers/passes.xhtml).

Z
:   Z depth, to be linked to the “Depth” render pass.

Samples
:   Quality factor.

Shutter
:   Duration of the motion blur in seconds, corresponding to the exposure time simulated for each frame.