PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Bpy.Types.Lightprobevolume in Blender? Include parameters, examples, warnings and best practices.

assistant: st bpy_struct.values ID.bl_system_properties_get ID.rename ID.evaluated_get ID.copy ID.asset_mark ID.asset_clear ID.asset_generate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py LightProbe.bl_rna_get_subclass LightProbe.bl_rna_get_subclass_py Next Lightgroup(bpy_struct) Previous LightProbeSphere(LightProbe) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page LightProbeVolume(LightProbe) LightProbeVolume LightProbeVolume.bake_samples LightProbeVolume.capture_distance LightProbeVolume.capture_emission LightProbeVolume.capture_indirect LightProbeVolume.capture_world LightProbeVolume.clamp_direct LightProbeVolume.clamp_indirect LightProbeVolume.dilation_radius LightProbeVolume.dilation_threshold LightProbeVolume.escape_bias LightProbeVolume.facing_bias LightProbeVolume.intensity LightProbeVolume.normal_bias LightProbeVolume.resolution_x LightProbeVolume.resolution_y LightProbeVolume.resolution_z LightProbeVolume.surface_bias LightProbeVolume.surfel_density LightProbeVolume.validity_threshold LightProbeVolume.view_bias LightProbeVolume.bl_rna_get_subclass() LightProbeVolume.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Creating Faces in a Blender add-on or script – include code.

assistant: [image reference removed]

Quad from an Edge with source automatically rotated.

If you have two vertices selected and already connected with an edge, `Ctrl`-`RMB` click
will create a planar face, also known as a quad. Blender will follow your mouse cursor
and will use the planar view from your viewport to create those quads.

For `Ctrl`-`RMB`, Blender will automatically rotate the last selected Edge (the source)
for the subsequent operations if you have at least one face created, dividing the angles created between
the newly created edge and the last two edges, creating a smooth angle between them. Blender will calculate
this angle using the last positive and negative position of the last X and Y coordinates
and the last connected unselected edge. If this angle exceeds a negative limit (following a quadrant rule)
between the recently created edge and the last two, Blender will wrap the faces.
But if you do not want Blender to rotate and smooth edges automatically when extruding from `Ctrl`-`RMB`,
you can also inhibit Blender from rotating sources using the shortcut `Shift`-`Ctrl`-`RMB`.
In this case, Blender will not rotate the source dividing the angle between those edges when creating a face.

If you have three or more vertices selected, and `Ctrl`-`RMB` click,
you will also create planar faces, but along the vertices selected, following the direction of the cursor.
This operation is similar to an extrude operation.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Transform
:   [Transformation Matrix](../../../../glossary/index.xhtml#term-Transformation-Matrix) containing the location, rotation and scale of the object.

Location
:   Location of the object in world space.

Rotation
:   Rotation of the object in world space.

Scale
:   Scale of the object in world space.

Geometry
:   Geometry of the object in world space with all its modifiers applied.
user: Explain Common Settings in complete detail according to the official Blender documentation.

assistant: Scale

Scale Randomness

Material
:   Set which of the object’s materials is used to shade the particles.

Coordinates System
:   Use a different object’s coordinates to determine the birth of particles.

Show Emitter
:   When disabled, the emitter is no longer rendered. Activate the button *Emitter* to also render the mesh.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Color 1/2
:   Color of the bricks.

Mortar
:   The color of the area between bricks.

Scale
:   Overall texture scale.

Mortar Size
:   The size of the filling between the bricks known as “mortar”; 0 means no mortar.

Mortar Smooth
:   Blurs/softens the edge between the mortar and the bricks.
    This can be useful with a texture and displacement textures.

Bias
:   The color variation between *Color 1/2*.
    Values of -1 and 1 only use one of the two colors; values in between mix the colors.

Brick Width
:   The width of the bricks.

Row Height
:   The height of the brick rows.
user: Describe Is Edge Loose Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Is Edge Loose Node

[image reference removed]

The *Is Edge Loose* node outputs a boolean value indicating whether each edge in a mesh
is *loose*. A loose edge is not connected to any faces, meaning it exists independently
of the mesh surface.

This node can be used to detect or isolate wireframe elements, stray geometry, or edges
intentionally used for guides or supports.
user: Describe Falloff from the Blender manual or Python API, including usage steps and snippets.

assistant: # Falloff

The *Falloff* is a curve that determines how the strength of the brush decreases
with increasing distance from the center. You can set up a custom curve or choose
a predefined one.

[image reference removed]

Brush falloff example.

Curve Preset
:   Custom
    :   Shows a [Curve Widget](../../interface/controls/templates/curve.html) for configuring a custom falloff.
        The left side of the curve corresponds to the center of the brush while the right side
        corresponds to the edge.

    Predefined
    :   The predefined falloff curves look as follows:

        Built-in falloff curves

        |  |  |  |
        | --- | --- | --- |
        | ../../_images/sculpt-paint_brush_falloff_smooth.png   Smooth | ../../_images/sculpt-paint_brush_falloff_smoother.png   Smoother | ../../_images/sculpt-paint_brush_falloff_sphere.png   Sphere |
        | ../../_images/sculpt-paint_brush_falloff_root.png   Root | ../../_images/sculpt-paint_brush_falloff_sharp.png   Sharp | ../../_images/sculpt-paint_brush_falloff_linear.png   Linear |
        | ../../_images/sculpt-paint_brush_falloff_sharper.png   Sharper | ../../_images/sculpt-paint_brush_falloff_invsquare.png   Inverse Square | ../../_images/sculpt-paint_brush_falloff_constant.png   Constant |

Falloff Shape
:   Determines how the falloff distance is calculated.

    Sphere:
    :   The falloff is calculated using a sphere in three-dimensional world space.
        If two points on the mesh appear near each other in the 3D Viewport but are
        far away in the world, painting one will not affect the other.

    Projected:
    :   The falloff is calculated using a circle in two-dimensional screen space.
        If two points on the mesh appear near each other in the 3D Viewport, painting
        one will also affect the other, no matter their distance in the world.

    Texture Paint Mode does not have this option – it always uses *Projected*.

Normal Falloff / Front-Face Falloff
:   Weakens the brush strength for faces whose normal points towards the screen edges
    instead of the camera.

    This feature is not available in Sculpt Mode.

    Angle
    :   The minimum angle between the face normal and the viewing direction for the
        falloff to start.
user: Show practical ways to work with Mouse Position Node in a Blender add-on or script – include code.

assistant: # Mouse Position Node

[image reference removed]

The *Mouse Position* node returns information about the mouse cursor
such as its position and the [region’s](../../../../interface/window_system/regions.xhtml) dimensions.
user: Explain Cryptomatte in complete detail according to the official Blender documentation.

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.xhtml).
    This option is not related to Blender’s
    [asset](../../files/asset_libraries/introduction.xhtml) 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: Show practical ways to work with UVs Explained in a Blender add-on or script – include code.

assistant: The best analogy to understand UV mapping is cutting up a cardboard box.
If you were to take a pair of scissors and cut along its edges,
you would be able to spread it out flat on a tabletop. As you are looking down at the table,
we could say that U is the left-right direction, and V is the up-down direction.

As a next step, you could put the spread-out box on top of a poster, cut the poster
to match its shape, glue the poster to the box, and finally reassemble the box.
You now have a 3D box textured with a 2D image.

A UV map thus describes how the mesh’s faces are laid out on the texture.
You have complete freedom in how to do this: if you wanted to, you could cut each face loose
and position, rotate, scale, and even skew it on the texture independently of the others.
What’s more, faces can overlap in the UV map, making them share the same part of the texture.

### Example

[image reference removed]

3D space (XYZ) versus UV space.

In the above image, a dome in 3D space is flattened into a disc in UV space.
Each 3D face is then textured with the part of the image it covers in the UV map.

The image also demonstrates a common problem in UV maps: distortion. Notice how,
even though the checkered squares in the 2D texture are all the same size,
they get different sizes when applied to the 3D dome (they’re smaller at the base
than at the top). This is because the faces in the UV map have different relative
sizes than in 3D space, which is a result of the flattening process.

You’ll typically want to minimize this distortion by manually guiding and tweaking
the flattening, using [seams](../../modeling/meshes/uv/unwrapping/seams.xhtml) for example.
However, it’s not always possible to eliminate it completely.
user: Show practical ways to work with Relax Pose to Breakdown in a Blender add-on or script – include code.

assistant: Relax pose is somewhat related to the above topic, but it is only useful with keyframed bones.
When you edit such a bone (and hence take it “away” from its “keyed position”),
using this tool will progressively “bring it back” to its “keyed position”,
with smaller and smaller steps as it comes near it.
user: How do I use CopyScaleConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CopyScaleConstraint(Constraint)

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

*class* bpy.types.CopyScaleConstraint(*Constraint*)
:   Copy the scale of the target

    power
    :   Raise the target’s scale to the specified power

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

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    use_add
    :   Use addition instead of multiplication to combine scale (2.7 compatibility)

        Type:
        :   boolean, default False

    use_make_uniform
    :   Redistribute the copied change in volume equally between the three axes of the owner

        Type:
        :   boolean, default False

    use_offset
    :   Combine original scale with copied scale

        Type:
        :   boolean, default False

    use_x
    :   Copy the target’s X scale

        Type:
        :   boolean, default False

    use_y
    :   Copy the target’s Y scale

        Type:
        :   boolean, default False

    use_z
    :   Copy the target’s Z scale

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Defines a rectangular region in the UV Editor to be used as a *Custom Region*

Once defined, this region can be selected as the *Pack To* target in the *Pack Islands* operator
by choosing **Custom Region** and enabling [Custom Region](#bpy-types-toolsettings-use-uv-custom-region).
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.html)
:   General and advanced settings.

[Texture](../../brush/texture.html)
:   Color and mask texture settings.

[Stroke](../../brush/stroke.html)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.html)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.html)
:   Cursor and appearance settings.
user: What is NodeSocketImage(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketImage(NodeSocketStandard)

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

*class* bpy.types.NodeSocketImage(*NodeSocketStandard*)
:   Image socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # ShaderNodeLightFalloff(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.ShaderNodeLightFalloff(*ShaderNode*)
:   Manipulate how light intensity decreases over distance. Typically used for non-physically-based effects; in reality light always falls off quadratically

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

assistant: `-a` `<options>` `<file(s)>`
:   Instead of showing Blender’s user interface, this runs Blender as an animation player,
    to view movies and image sequences rendered in Blender (ignored if `-b` is set).

    Playback Arguments:

    `-p` `<sx>` `<sy>`
    :   Open with lower left corner at `<sx>`, `<sy>`.

    `-m`
    :   Read from disk (Do not buffer).

    `-f` `<fps>` `<fps_base>`
    :   Specify FPS to start with.

    `-j` `<frame>`
    :   Set frame step to `<frame>`.

    `-s` `<frame>`
    :   Play from `<frame>`.

    `-e` `<frame>`
    :   Play until `<frame>`.

    `-c` `<cache_memory>`
    :   Amount of memory in megabytes to allow for caching images during playback.
        Zero disables (clamping to a fixed number of frames instead).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Plastic / Wall In / Wall out
:   Plastic is the standard Stucci, while the “walls” is where Stucci gets it name.
    This is a typical wall structure with holes or bumps.

Soft / Hard
:   There are two methods available for working with Noise.

Size
:   Dimension of the Noise table.

Turbulence
:   Depth of the *Stucci* calculations.
user: Describe Videos from the Blender manual or Python API, including usage steps and snippets.

assistant: Embed videos hosted on Blender’s PeerTube at [video.blender.org](https://video.blender.org/).

```
.. peertube:: ID
```

The `ID` is extracted from the video URL, e.g.:

`https://video.blender.org/videos/watch/47448bc1-0cc0-4bd1-b6c8-9115d8f7e08c`
The ID is: `47448bc1-0cc0-4bd1-b6c8-9115d8f7e08c`.

### Guidelines for Videos

- Prefer videos without spoken or textual explanations for easier translation.
- Do not rely solely on videos to explain features. The manual text itself should clearly document the process.
user: Describe Color Management from the Blender manual or Python API, including usage steps and snippets.

assistant: # Color Management

Color management is important to create renders and assets that are physically accurate and look great
on multiple display devices. It is used both to ensure all parts of the pipeline interpret colors correctly,
and to make artistic choices about the look.
user: Show practical ways to work with Motionpath Display Type Items in a Blender add-on or script – include code.

assistant: # Motionpath Display Type Items

CURRENT_FRAME:
:   Around Frame.

    Display Paths of poses within a fixed number of frames around the current frame.

RANGE:
:   In Range.

    Display Paths of poses within specified range.
user: What is NodeTreeInterfaceSocketMatrix(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketMatrix(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.NodeTreeInterfaceSocketMatrix(*NodeTreeInterfaceSocket*)
:   Matrix value socket of a node

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

assistant: # SDF Grid Laplacian Node

[image reference removed]

The *SDF Grid Laplacian* node applies Laplacian flow smoothing to a Signed Distance Field (SDF) grid.
This process gradually smooths the surface of the SDF by diffusing fine
details and noise across neighboring voxels, resulting in a cleaner, more uniform field.

Laplacian flow is a computationally efficient alternative to
[mean curvature flow](sdf_grid_mean_curvature.html)
smoothing. It is particularly useful for refining SDFs generated from
meshes or boolean operations, where sharp transitions or voxel artifacts may occur.
The operation helps improve the quality of surfaces before converting the SDF back into a mesh.
user: Show practical ways to work with Voronoi in a Blender add-on or script – include code.

assistant: # Voronoi

The Voronoi texture is used to generate very convincing Metal,
especially the “Hammered” effect. Organic shaders (e.g. scales, veins in skin).

[image reference removed]

Voronoi Texture panels.
user: Provide the full official documentation entry for GeometryNodeFieldMinAndMax(GeometryNode), preserving all code examples.

assistant: # GeometryNodeFieldMinAndMax(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.GeometryNodeFieldMinAndMax(*GeometryNode*)
:   Calculate the minimum and maximum of a given field

    data_type
    :   Type of data the outputs are calculated from

        - `FLOAT`
          Float – Floating-point value.
        - `INT`
          Integer – 32-bit integer.
        - `FLOAT_VECTOR`
          Vector – 3D vector with floating-point values.

        Type:
        :   enum in [`'FLOAT'`, `'INT'`, `'FLOAT_VECTOR'`], default `'FLOAT'`

    domain
    :   Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'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: How do I use Dirty Vertex Colors in Blender? Include parameters, examples, warnings and best practices.

assistant: Generate a dirt map gradient based on cavity.

Blur Strength
:   Blur strength per iteration.

Blur Iterations
:   Number of times to blur the colors (higher blurs more).

Highlight Angle
:   Clamps the angle for convex areas of the mesh.
    Lower values increase the contrast but can result in clamping.
    90 means flat, 180 means infinitely pointed.

Dirt Angle
:   Clamps the angle for concave areas of the mesh.
    Higher values increase the contrast but can result in clamping.
    90 means flat, 0 means infinitely deep.

Dirt Only
:   When active it won’t calculate cleans for convex areas.

Normalize
:   Choose optimal contrast by effectively lowering
    *Highlight Angle* and increasing *Dirt Angle* automatically.
    Disabling *Normalize* allows getting consistent results across multiple objects.
user: What is Start Tweaking Strips Actions (Lower Stack) and how is it used in Blender Python scripting?

assistant: Enters Tweak Mode for the selected strip’s action, making its keyframes available for editing.
Mutes any tracks above the current one so that they don’t influence the animation while making changes.

When you’re done, click Strip ‣ Stop Tweaking Strips Actions or press `Tab`.
user: How do I use ShaderNodeTexCoord(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeTexCoord(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.ShaderNodeTexCoord(*ShaderNode*)
:   Retrieve multiple types of texture coordinates.
    Typically used as inputs for texture nodes

    from_instancer
    :   Use the parent of the instance object if possible

        Type:
        :   boolean, default False

    object
    :   Use coordinates from this object (for object texture coordinates output)

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

    *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 Retopology from the Blender manual or Python API, including usage steps and snippets.

assistant: The automatic remesh tools generally don’t result in topology that lends itself to deformation.
Therefore, if you have sculpted a character and want to simplify it for animation,
you’ll typically have to do this manually in a process known as retopologizing.

To do this, you typically create a new mesh that overlaps the original one,
then adjust it until it fully covers the original mesh and matches its shape.

- The [Retopology](../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-retopology) overlay of the 3D Viewport is useful here,
  as it lets you see the original mesh through the retopologized one and vice versa –
  without getting distracted by geometry on the other side as would be the case with
  [X-Ray](../../editors/3dview/display/shading.xhtml#bpy-types-view3dshading-show-xray).
- You can use the [Poly Build](tools/poly_build.xhtml) tool to quickly add, change,
  and remove faces.
- Use [Snapping](../../editors/3dview/controls/snapping.xhtml) to align new vertices to the original mesh.
user: Give a detailed overview of ActionStrip(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ActionStrip(bpy_struct)

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

subclasses —
[`ActionKeyframeStrip`](bpy.types.ActionKeyframeStrip.html#bpy.types.ActionKeyframeStrip "bpy.types.ActionKeyframeStrip")

*class* bpy.types.ActionStrip(*bpy_struct*)
:   type
    :   - `KEYFRAME`
          Keyframe – Strip with a set of F-Curves for each action slot.

        Type:
        :   enum in [`'KEYFRAME'`], default `'KEYFRAME'`, (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](#bpy.types.ActionStrip.type "bpy.types.ActionStrip.type")
user: Show practical ways to work with Cursor in a Blender add-on or script – include code.

assistant: # Cursor

[[image reference removed]](../../_images/sculpt-paint_brush_cursor_panel.png)

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

assistant: # NodeTreeInterfaceSocketFloatUnsigned(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.NodeTreeInterfaceSocketFloatUnsigned(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float in [0, inf], default 0.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: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`LatticePoint.groups`](bpy.types.LatticePoint.html#bpy.types.LatticePoint.groups "bpy.types.LatticePoint.groups") | - [`MeshVertex.groups`](bpy.types.MeshVertex.html#bpy.types.MeshVertex.groups "bpy.types.MeshVertex.groups") |
user: How do I use Grid Laplacian Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Grid Laplacian Node

[image reference removed]

The *Grid Laplacian* node computes the Laplacian of a scalar voxel grid.
The Laplacian measures how a value at each voxel differs from the average
of its neighbors—essentially, how much the field “curves” or deviates locally.

Mathematically, the Laplacian is defined as the divergence of the gradient
of a scalar field. It is commonly used in physics and geometry for diffusion,
smoothing, curvature analysis, and solving partial differential equations.

For a scalar field \(f(x, y, z)\), the Laplacian \(\nabla^2 f\)
is given by:

\[\nabla^2 f = \nabla f =
\frac{\partial^2 f}{\partial x^2} +
\frac{\partial^2 f}{\partial y^2} +
\frac{\partial^2 f}{\partial z^2}\]

The Laplacian is positive where the field has a local minimum (value smaller
than its surroundings) and negative where it has a local maximum (value
larger than its surroundings).
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the arc.

Different thickness profile samples.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_arc_thickness-profile-01.png | ../../../../_images/grease-pencil_modes_draw_tools_arc_thickness-profile-02.png | ../../../../_images/grease-pencil_modes_draw_tools_arc_thickness-profile-03.png |

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Curves
:   Either plain curves or curve instances.

Selection
:   Either a curve or instance selection.

Instances as Layers
:   Create a separate layer for each instance. If instances are used, realized curve geometry will be
    ignored. Layer names will use the instance geometry name. If real curve geometry is used, a single
    layer is created with the input geometry’s name.
user: Explain Workflow in complete detail according to the official Blender documentation.

assistant: At least a [Domain](type/domain/index.html) object and
one [Flow](type/flow.html) object are required to create a fluid simulation.

1. Create a [Domain object](type/domain/index.html)
   that defines the bounds of the simulation volume.
2. Set up [Flow](type/flow.html) objects which will emit fluid.
3. Set up [Effector](type/effector.html) objects to make
   the fluid interact with objects in the scene.
4. Assign a [material](material.html) to the domain object.
5. Save the blend-file.
6. [Bake the Cache](type/domain/cache.html) for the simulation.
user: Explain ThemeWidgetColors(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ThemeWidgetColors(bpy_struct)

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

*class* bpy.types.ThemeWidgetColors(*bpy_struct*)
:   Theme settings for widget color sets

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

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

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

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

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

    roundness
    :   Amount of edge rounding

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

    shadedown
    :   Type:
        :   int in [-100, 100], default 0

    shadetop
    :   Type:
        :   int in [-100, 100], default 0

    show_shaded
    :   Type:
        :   boolean, default False

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Geometry
:   The resulting geometry with duplicated hair curves.

Guide Index
:   An integer attribute storing the index of the original guide curve for each duplicate.
    This can be used for further operations such as matching colors or following guide motion.
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleColorModifier.name`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier.name "bpy.types.LineStyleColorModifier.name") |
user: Explain Chains of Bones in complete detail according to the official Blender documentation.

assistant: The bones inside an armature can be completely independent from each other
(i.e. the modification of one bone does not affect the others).
But this is not often a useful set up: To create a leg,
all bones “after” the thigh bone should move “with” it in a well-coordinated manner.
This is exactly what happens in armatures by parenting a bone to the next one in the limb,
you create a “chains of bones”. These chains can be ramified. For example,
five fingers attached to a single “hand” bone.

[image reference removed]

An armature with two chains of bones.

Bones are chained by linking the tip of the parent to the root of the child.
Root and tip can be *connected*, i.e. they are always exactly at the same point;
or they can be *free*, like in a standard parent-child object relationship.

A given bone can be the parent of several children,
and hence be part of several chains at the same time.

The bone at the beginning of a chain is called its *root bone*,
and the last bone of a chain is the *tip bone*
(do not confuse them with similar names of bones’ joints!).

Chains of bones are a particularly important topic in [posing](posing/index.xhtml)
(especially with the standard *forward* kinematics versus “automatic” *inverse* kinematics posing techniques).
You create/edit them in *Edit Mode*, but except in case of connected bones,
their relationships have no effect on bone transformations in this mode
(i.e. transforming a parent bone will not affect its children).

The easiest way to manage bones relationships is to use
the [Relations panel](bones/properties/relations.xhtml#bpy-types-editbone-parent) in the Bone tab.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image/Color
:   Standard color input.

Hue
:   The hue rotation offset, from 0 (-180°) to 1 (+180°). Note that
    0 and 1 have the same result.

Saturation
:   A value of 0 removes color from the image, making it black-and-white.
    A value greater than 1.0 increases saturation.

Value
:   The value shift. 0 makes the color black, 1 keeps it the same, and higher
    values make it brighter.

Factor
:   The amount of influence the node exerts on the image.
user: Give a detailed overview of SDF Grid Laplacian Node: syntax, arguments, return values, common patterns.

assistant: # SDF Grid Laplacian Node

[image reference removed]

The *SDF Grid Laplacian* node applies Laplacian flow smoothing to a Signed Distance Field (SDF) grid.
This process gradually smooths the surface of the SDF by diffusing fine
details and noise across neighboring voxels, resulting in a cleaner, more uniform field.

Laplacian flow is a computationally efficient alternative to
[mean curvature flow](sdf_grid_mean_curvature.xhtml)
smoothing. It is particularly useful for refining SDFs generated from
meshes or boolean operations, where sharp transitions or voxel artifacts may occur.
The operation helps improve the quality of surfaces before converting the SDF back into a mesh.
user: Give a detailed overview of Aerodynamics: syntax, arguments, return values, common patterns.

assistant: Force from surrounding media.
See [exterior forces](../forces/exterior.html#physics-softbody-forces-exterior-aerodynamics) for details.

Type
:   Simple:
    :   Edges receive a drag force from the surrounding media.

    Lift Force:
    :   Edges receive a lift force when passing through the surrounding media.

Factor
:   How much aerodynamic force to use. Try a value of 30 at first.