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

assistant: # Face Area Node

[image reference removed]

The *Face Area* node outputs the surface area of a mesh’s faces.
The units are in Blender units no matter the unit system,
equivalent to meters-squared at the default unit scale.
user: Give a detailed overview of NodeTreeInterfaceSocketBool(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   boolean, default False

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

assistant: # Curve Modifier

The *Curve* modifier provides a simple but efficient method of deforming a mesh along a curve object.

It works on a (global) dominant axis, X, Y, or Z.
This means that when you move your mesh in the dominant direction (by default, the X axis),
the mesh will traverse along the curve, as if it was a train following and deforming along rails.
Moving the mesh perpendicularly to this axis, the object will move closer or further away from the curve.

When you move the object beyond the curve’s ends, the object will continue
to deform based on the direction vector at those ends.

If the curve is 3D, the *Tilt* value of its control points will be used to twist the deformed object.
And the *Radius* property controls the size of the object as well.
Those options are in the *Shape* panel, under [Path/Curve-Deform](../../curves/properties/shape.html#curve-shape-path-curve-deform).
user: Explain Bpy.Types.Greasepencilsmoothmodifier in complete detail according to the official Blender documentation.

assistant: er.use_edit_position GreasePencilSmoothModifier.use_edit_strength GreasePencilSmoothModifier.use_edit_thickness GreasePencilSmoothModifier.use_edit_uv GreasePencilSmoothModifier.use_keep_shape GreasePencilSmoothModifier.use_layer_group_filter GreasePencilSmoothModifier.use_layer_pass_filter GreasePencilSmoothModifier.use_material_pass_filter GreasePencilSmoothModifier.use_smooth_ends GreasePencilSmoothModifier.vertex_group_name GreasePencilSmoothModifier.bl_rna_get_subclass() GreasePencilSmoothModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Describe Evaluate Closure from the Blender manual or Python API, including usage steps and snippets.

assistant: # Evaluate Closure

[image reference removed]

The *Evaluate Closure* node executes a connected [Closure Zone](../../../../interface/controls/nodes/types/utilities/closure/closure.xhtml).
It acts as the *call site* of the closure, running its internal node graph and returning the resulting values.

Closures enable dynamic and customizable node groups by allowing users to pass procedural logic into another node tree.
When the *Evaluate Closure* node runs, the connected closure is evaluated within the current context, matching its input
and output sockets by name.

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: Describe Material Shader from the Blender manual or Python API, including usage steps and snippets.

assistant: Grease Pencil materials use a special [shader](properties.xhtml)
that define the appearance of the surface of the stroke and fill.

Stroke and fill components has it own section panel and
they can be enabled with a checkbox on the panel header.

*Stroke* only has effect on the lines and *Fill* only on the areas
determined by closed lines (by connecting the lines start and end points).
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Glow Visual Effect.

Mode
:   Determines the mode for the glow effect.

    Luminance:
    :   The glow light illuminates the entire object.

    Color:
    :   The glow light only affect a single color.

        Select Color
        :   Allows to select a single color to apply the glow light.

Threshold
:   Limits the colors affected by the glow light. (A value of 1 means no colors affected.)

Glow Color
:   Defines the glow color.

Blend Mode
:   The mask blending operation to perform. See [Color Blend Modes](../../glossary/index.xhtml#term-Color-Blend-Modes).

Opacity
:   Control the Opacity of the glow over the object.

Size X, Y
:   Control the glow scale in pixels on the X and Y axis.

Rotation
:   Control the Rotation of the glow.

Samples
:   Number of Blur samples (0 disabled the blur effect).

Glow Under
:   When enabled, glow only affects alpha areas.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Transform
:   The transform matrix that converts from grid index space to object space.
    Defines how the grid’s voxels are positioned, scaled, and oriented in 3D space.
    This can be passed to nodes such as
    [Set Grid Transform](../write/set_grid_transform.xhtml)
    or used to align other grids or geometry.

Background Value
:   The value assigned to inactive voxels in the grid.
    This represents the default or “empty” value used when sampling outside of active regions, as set by the
    [Set Grid Background](../write/set_grid_background.xhtml)
    node or similar operations.
user: Explain Evaluate on Domain Node in complete detail according to the official Blender documentation.

assistant: # Evaluate on Domain Node

[image reference removed]

The *Evaluate on Domain* allows evaluating a field for a different [attribute domain](../../attributes_reference.xhtml#attribute-domains)
than the domain from the [field context](../../fields.xhtml#field-context). For example, the face index could be used instead
of the face corner index, when setting the values of a [UV Map](../../../../glossary/index.xhtml#term-UV-Map)
user: Give a detailed overview of Vertex Group Categories: syntax, arguments, return values, common patterns.

assistant: While all vertex groups are technically the same, we can still divide them into two types
depending on how they’re used:

Deform Groups
:   Also sometimes called “weight group” or “weight map,” this type of vertex group determines
    which vertices are affected by a certain bone in the
    [Armature](../../../../animation/armatures/introduction.html). In other words, it defines which part
    of the mesh deforms when the bone moves around.

Other Groups
:   The remaining vertex groups are used with shape keys, modifiers, and other areas.

The deform vertex groups are related to each other: the deformation weights of every vertex
typically need to add up to 1. For this reason, you can use the filter buttons at the top
of the panel to show only these vertex groups (or to exclude them).
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`PreferencesExtensions.repos`](bpy.types.PreferencesExtensions.html#bpy.types.PreferencesExtensions.repos "bpy.types.PreferencesExtensions.repos") - [`UserExtensionRepoCollection.new`](bpy.types.UserExtensionRepoCollection.html#bpy.types.UserExtensionRepoCollection.new "bpy.types.UserExtensionRepoCollection.new") | - [`UserExtensionRepoCollection.remove`](bpy.types.UserExtensionRepoCollection.html#bpy.types.UserExtensionRepoCollection.remove "bpy.types.UserExtensionRepoCollection.remove") |
user: How do I use Mesh to SDF Grid Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Mesh to SDF Grid Node

[image reference removed]

The *Mesh to SDF Grid* node converts a mesh into a Signed Distance Field (SDF)
grid. Each voxel in the resulting grid stores the shortest distance to the
surface of the mesh, with the sign indicating whether the voxel is inside or
outside the mesh.

Positive values represent distances outside the mesh, negative values represent
distances inside the mesh, and zero corresponds to the mesh surface.
SDF grids are useful for many applications, including surface reconstruction,
collision detection, morphing, and volumetric modeling.
user: What is Usage and how is it used in Blender Python scripting?

assistant: The *Evaluate Closure* node is typically used to make a node group partially customizable while maintaining a stable,
reusable framework.

For example, a terrain generator might use *Evaluate Closure* to define how trees are distributed across a landscape:

1. Inside the generator group, replace the fixed tree placement logic with an *Evaluate Closure* node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, connect a *Closure Zone* defining the desired tree distribution behavior.

Whenever the closure is evaluated, the connected node graph runs within the terrain generator’s context, producing a
customized result.

[image reference removed]

Example: custom tree distribution using *Evaluate Closure*.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Soft body simulation is used for simulating soft deformable objects.
It was designed primarily for adding secondary motion to animation,
like jiggle for body parts of a moving character.

It also works for simulating more general soft objects that bend, deform and
react to forces like gravity and wind, or collide with other objects.

While it can simulate cloth and other stiff types of deformable objects to
an extent, the [Cloth Simulation](../cloth/index.html) can do it better
with a solver specifically designed for this purpose.

The simulation works by combining existing animation on the object with forces
acting on it. There are exterior forces like gravity or force fields and
interior forces that hold the vertices together.
This way you can simulate the shapes that an object would take on in reality if it had volume,
was filled with something, and was acted on by real forces.

Soft bodies can interact with other objects through *Collision*.
They can interact with themselves through *Self-Collision*.

The result of the soft body simulation can be converted to a static object.
You can also *bake edit* the simulation, i.e.
edit intermediate results and run the simulation from there.
user: Give a detailed overview of Smooth Modifier: syntax, arguments, return values, common patterns.

assistant: # Smooth Modifier

The *Smooth* modifier smooths a mesh by flattening the angles between adjacent faces in it,
just like the [Smooth tool](../../meshes/editing/vertex/smooth_vertices.xhtml#bpy-ops-mesh-vertices-smooth) in Edit Mode.
It smooths without subdividing the mesh, the number of vertices remains the same.

This modifier is not limited to smoothing, though.
Its control factor can be configured outside the (0.0 to 1.0) range
(including negative values), which can result in interesting deformations.
user: How do I use Join Strings Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Join Strings Node

[image reference removed]

The *Join Strings* node combines any number of input strings into the output string.
The order of the result depends on the vertical ordering of the inputs in the multi-input socket.
user: How do I use Store Named Grid Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Store Named Grid Node

[image reference removed]

The *Store Named Grid* node stores a voxel grid inside a volume geometry under a specified name.
This allows multiple grids (such as *density*, *temperature*, or *velocity*) to
be contained within a single volume object and accessed later using the
[Get Named Grid](../read/get_named_grid.xhtml) node.

If a grid with the same name already exists in the input volume, it will be replaced by the new grid.
This makes it possible to update or overwrite grids during a geometry node
evaluation, for example when generating or modifying simulation fields.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input image.

Contrast
:   Adjusts the difference between light and dark areas.
    Increasing contrast deepens shadows and brightens highlights,
    while decreasing it flattens the image’s tonal range.

Color Boost
:   Enhances the intensity of colors without oversaturating them.
    Useful for enriching dull or washed-out images.

Clarity
:   Emphasizes midtone contrast and local details,
    improving the sense of depth and definition.

Detail
:   Adjusts the visibility of small-scale texture information.
    Higher values bring out fine details; lower values smooth them.

Sharpen
:   Increases edge definition by enhancing high-frequency detail.
    Useful for counteracting blur from downsampling or lens effects.

Preserve Colors
:   Maintains natural color balance when applying tonal adjustments.
    When disabled, contrast and clarity may shift the color hue or saturation.
user: Describe Curve Tip from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve Tip

The *Curve Tip* node outputs information about the tip (end) point of each curve.
It is commonly used in hair grooming, deformation, and simulation setups to control
operations at the ends of curves, such as shaping, alignment, or applying tip-based effects.
user: What is Render Settings and how is it used in Blender Python scripting?

assistant: # Render Settings

Device
:   Specifies the compute device used for rendering in Cycles.
    The choice of device can significantly affect render performance, *GPU Compute* is often faster .

    CPU:
    :   Render using the system’s central processing unit. This mode is compatible with all Cycles features.
        The number of CPU threads used can be changed in the
        [Performance Properties](performance.xhtml).

    GPU Compute:
    :   Render using one or more graphics processing units (GPUs) through the compute backend
        and devices selected in the [Cycles Render Devices](../../../editors/preferences/system.xhtml#editors-preferences-cycles).
        Depending on the backend, it may be possible to use both CPU and GPU devices simultaneously.

        For more details, including setup instructions, device compatibility, and known limitations,
        see [GPU Rendering](../gpu_rendering.xhtml).

Open Shading Language
:   Enables the use of [Open Shading Language](../osl/index.xhtml) which allows custom shading using shader scripts.
    When OSL is enabled, you can:

    - Use OSL shader nodes in materials using the [Script Node](../../shader_nodes/utilities/script.xhtml).
    - Write custom shading logic that is not possible with built-in Cycles nodes.

    Limitations:

    - OSL is supported only when rendering with the *CPU* or with the
      [OptiX](../gpu_rendering.xhtml#render-cycles-gpu-optix) GPU Compute backend.
    - Rendering performance is typically slower than with built-in nodes due to shader compilation and interpretation.
    - Some features, such as baking and certain volume shaders, may not work with OSL.
user: Explain Proportional Editing in complete detail according to the official Blender documentation.

assistant: Proportional Editing is available in UV editing. The controls are the same as in the 3D Viewport.
See [Proportional Editing in 3D](../../../editors/3dview/controls/proportional_editing.xhtml)
for a full reference.
user: Show practical ways to work with LineStyleAlphaModifier_Curvature_3D(LineStyleAlphaModifier) in a Blender add-on or script – include code.

assistant: # LineStyleAlphaModifier_Curvature_3D(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_Curvature_3D(*LineStyleAlphaModifier*)
:   Alpha transparency based on the radial curvature of 3D mesh surfaces

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curvature_max
    :   Maximum Curvature

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

    curvature_min
    :   Minimum Curvature

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

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        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](#bpy.types.LineStyleAlphaModifier_Curvature_3D.type "bpy.types.LineStyleAlphaModifier_Curvature_3D.type")
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   The input geometry containing the hair curves to deform into curls.

Factor
:   Controls the overall strength of the curling effect.
    A value of 0.0 disables the effect, while 1.0 applies the full curl deformation.

Subdivision
:   The number of subdivisions applied to curves before deformation.
    Higher values produce smoother curls but increase processing time.

Curl Start
:   Defines the percentage along each curve (from root to tip) at which the curl effect begins.
    This allows keeping part of the strand straight before the curl starts.

Radius
:   The overall radius of the curls.
    Larger values produce looser curls, while smaller values create tighter spirals.

Factor Start
:   Multiplies the curl radius near the start of the curl region, allowing tapering or
    gradual buildup of curl tightness.

Factor End
:   Multiplies the curl radius near the end of the curve, controlling how curls taper off
    or unwind toward the tip.

Frequency
:   Controls how many full rotations occur along the length of the curve.
    Higher values produce more frequent curls.
    This input can vary per point along the curve, allowing complex wave patterns.

Random Offset
:   Adds random variation to the curl phase or starting angle per curve, creating a
    more natural, less uniform look.

Seed
:   Sets the random seed used for generating the random offsets.
    Changing this value produces different curl variations while maintaining the same parameters.

### Guide Map

Guide Index
:   A map that specifies which curve should act as the guide or central reference
    for each group of curled curves.
    If provided, this overrides any existing `guide_curve_index` attribute,
    and the *Guide Distance* and *Guide Mask* inputs are ignored.

Guide Distance
:   The minimum spacing between selected guides when generating a new guide map.
    Larger values result in fewer guide curves and broader curl groups.

Guide Mask
:   A mask that determines which curves are eligible to be used as guides.

Existing Guide Map
:   When enabled, uses the existing guide map attribute if one is already present.
    If disabled and *Guide Index* is not provided, a new
    [guide map](create_guide_index_map.xhtml)
    is created using *Guide Distance* and *Guide Mask*.
    Creating the guide map separately allows for more control and consistency
    across multiple grooming operations.
user: Give a detailed overview of SimpleDeformModifier(Modifier): syntax, arguments, return values, common patterns.

assistant: # SimpleDeformModifier(Modifier)

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

*class* bpy.types.SimpleDeformModifier(*Modifier*)
:   Simple deformation modifier to apply effects such as twisting and bending

    angle
    :   Angle of deformation

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

    deform_axis
    :   Deform around local axis

        Type:
        :   enum in [Axis Xyz Items](bpy_types_enum_items/axis_xyz_items.html#rna-enum-axis-xyz-items), default `'X'`

    deform_method
    :   - `TWIST`
          Twist – Rotate around the Z axis of the modifier space.
        - `BEND`
          Bend – Bend the mesh over the Z axis of the modifier space.
        - `TAPER`
          Taper – Linearly scale along Z axis of the modifier space.
        - `STRETCH`
          Stretch – Stretch the object along the Z axis of the modifier space.

        Type:
        :   enum in [`'TWIST'`, `'BEND'`, `'TAPER'`, `'STRETCH'`], default `'TWIST'`

    factor
    :   Amount to deform object

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

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    limits
    :   Lower/Upper limits for deform

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

    lock_x
    :   Do not allow deformation along the X axis

        Type:
        :   boolean, default False

    lock_y
    :   Do not allow deformation along the Y axis

        Type:
        :   boolean, default False

    lock_z
    :   Do not allow deformation along the Z axis

        Type:
        :   boolean, default False

    origin
    :   Offset the origin and orientation of the deformation

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

    vertex_group
    :   Vertex group name

        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: Explain GeometryNodeInputInstanceScale(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInputInstanceScale(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.GeometryNodeInputInstanceScale(*GeometryNode*)
:   Retrieve the scale of each instance in the geometry

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Set Corner Type in complete detail according to the official Blender documentation.

assistant: Sets how corners between strokes or segments are shaped when using stroke
thickness or fills. This affects how the stroke geometry joins at sharp angles.

Corner Type
:   Defines the style of the corner for the selected points.

    Round:
    :   Smoothly rounds the corner, creating a curved transition between segments.

    Flat:
    :   Cuts the corner flat, creating a beveled join.

    Sharp:
    :   Keeps the corner pointed, preserving the original angle between segments.

Miter Cut Angle
:   Specifies the angle threshold (in degrees) for flattening sharp corners.
    Any corner sharper than this angle will be cut flat when *Corner Type* is set to *Flat* or *Round*.
user: Describe NodeJoinBundle(NodeInternal) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeJoinBundle(NodeInternal)

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

*class* bpy.types.NodeJoinBundle(*NodeInternal*)
:   Join multiple bundles together

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Saving your Composite Image: syntax, arguments, return values, common patterns.

assistant: The *Render* button renders a single frame or image.
Save your image using [Save Image](../editors/image/editing.html#bpy-ops-image-save).
The image will be saved using the image format settings on the Render panel.

To save a sequence of images, for example,
if you input a movie clip or used a Time node with each frame in its own file,
use the *Animation* button and its settings. If you might want to later overlay them,
be sure to use an image format that supports an Alpha channel (such as `PNG`).
If you might want to later arrange them front to back or create a depth of field effect,
use a format that supports a Z-depth channel (such as `EXR`).

To save a composition as a movie clip (all frames in a single file),
use an `AVI` or `QuickTime` format, and use the *Animation* button and its settings.
user: Provide the full official documentation entry for Object Empty Drawtype Items, preserving all code examples.

assistant: # Object Empty Drawtype Items

PLAIN_AXES:
:   Plain Axes.

ARROWS:
:   Arrows.

SINGLE_ARROW:
:   Single Arrow.

CIRCLE:
:   Circle.

CUBE:
:   Cube.

SPHERE:
:   Sphere.

CONE:
:   Cone.

IMAGE:
:   Image.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`CompositorNodeCryptomatteV2.entries`](bpy.types.CompositorNodeCryptomatteV2.html#bpy.types.CompositorNodeCryptomatteV2.entries "bpy.types.CompositorNodeCryptomatteV2.entries") |  |
user: Show practical ways to work with Changing Tools in a Blender add-on or script – include code.

assistant: If you have *Alt Click Tool Prompt* enabled in the Keymap Preferences,
tapping `Alt` will display a tool prompt in the Status Bar.
You can then press a key to select the corresponding tool, or tap `Alt` again to cancel the prompt.

### Fallback Tool

The fallback tool is the one that’s selected by default (so the one at the top of the Toolbar).
You can change it by either holding `LMB` on the toolbar button or pressing `Alt`-`W`
to get a pie menu.

### Cycling Tools

If you bind a key to a tool which is part of a group, you can enable the *Cycle* option in the keymap editor.
Successive presses will then cycle through the tools in that group.

This is enabled by default for the selection tools in the 3D Viewport, for example:
pressing `W` will cycle between Select Box, Select Circle and so on.
user: Provide the full official documentation entry for Mesh Edit Mode Overlays, preserving all code examples.

assistant: The following options are available when in Mesh Edit Mode.

Faces
:   Highlight selected faces. Affects all selection modes.

Center
:   Show face center points in solid shading modes. (They’re always shown in wireframe shading mode.)

    Only affects face selection mode.

Creases
:   Display edges marked with a crease
    for the [Subdivision Surface Modifier](../../../modeling/modifiers/generate/subdivision_surface.xhtml).

Sharp
:   Display sharp edges, used with the [Edge Split modifier](../../../modeling/modifiers/generate/edge_split.xhtml).

Bevel
:   Display weights created for the [Bevel Modifier](../../../modeling/modifiers/generate/bevel.xhtml).

Seams
:   Display the [UV unwrapping seams](../../../modeling/meshes/uv/unwrapping/seams.xhtml).

Indices
:   Display the indices of selected vertices, edges, and faces.

### Shading

Retopology
:   This overlay is useful when you have a sculpted mesh with the desired shape and
    want to recreate it with better topology. It makes the edited mesh see-through
    (so that you can see the sculpted mesh underneath it) and optionally renders it
    in front of nearby geometry (so that you can see it underneath the sculpted mesh).

    Offset
    :   Distance to “move the edited mesh towards the camera.” Use this to display the
        mesh in front of other objects that would normally occlude it.

Vertex Groups Weights
:   Visualize the weights of the active vertex group,
    much like in [Weight Paint](../../../sculpt_paint/weight_paint/introduction.xhtml) mode.

    Zero Weights
    :   Display unreferenced and zero-weighted areas in black.
        This helps to identify areas with very low weights that have been painted onto.

        None:
        :   Vertices are displayed in the usual way.

        Active:
        :   Vertices are shown in black if they have no weight in the active vertex group.

        All:
        :   Vertices are shown in black if they have no weight in any vertex group.

### Mesh Analysis

Show the [Mesh Analysis](../../../modeling/meshes/mesh_analysis.xhtml#modeling-mesh-analysis) overlay.

### Measurement

Show numerical measures of the selected elements.
The [Units](../../../scene_layout/scene/properties.xhtml#bpy-types-unitsettings) can be set in the Scene properties.

Edge Length
:   Show the length of selected edges.

Edge Angle
:   Show the angle of selected edges between two faces.

Face Area
:   Show the area of selected faces.

Face Angle
:   Show the angle of selected face corners.

### Normals

- Display vertex normals
- Display face normals at vertices (split normals)
- Display face normals

Size
:   The size to show the selected normals.

    Constant Screen Size Normals
    :   Keep the size of normals constant in relation to the zoom level.

### Freestyle

These settings apply to the [Freestyle](../../../render/freestyle/introduction.xhtml)
Line Art renderer.

Edge Marks
:   Display Freestyle edge marks.

Face Marks
:   Display Freestyle face marks.
user: How do I use Simple Contribution in Blender? Include parameters, examples, warnings and best practices.

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

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

Weblate also provides tools such as the
[glossary](https://translate.blender.org/projects/blender-manual/glossary/) to improve translation consistency.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Vertex Weight Mix modifier panel.

Vertex Group A, B
:   - **A**: The vertex group to affect.
    - **B**: The second vertex group to mix into the affected one.
      Leave it empty if you only want to mix in a simple value.

    Invert Weights A/B
    :   Invert the influence of the vertex group.

Default Weight A, B
:   - **A**: The default weight to assign to all vertices not in the given vertex group.
    - **B**: The default weight to assign to all vertices not in the given second vertex group.

Vertex Set
:   Choose which vertices will be affected.

    All:
    :   Affects all vertices, disregarding the vertex groups content.

    Vertex Group A:
    :   Affects only vertices belonging to the affected vertex group.

    Vertex Group B:
    :   Affects only vertices belonging to the second vertex group.

    Vertex Group A or B:
    :   Affects only vertices belonging to at least one of the vertex groups.

    Vertex Group A and B:
    :   Affects only vertices belonging to both vertex groups.

Mix Mode
:   How the vertex group weights are affected by the other vertex group’s weights.

    Replace:
    :   Replaces affected weights with the second group’s weights.

    Add:
    :   Adds the values of *Group B* to *Group A*.

    Subtract:
    :   Subtracts the values of *Group B* from *Group A*.

    Multiply:
    :   Multiplies the values of *Group B* with *Group A*.

    Divide:
    :   Divides the values of *Group A* by *Group B*.

    Difference:
    :   Subtracts the smaller of the two values from the larger.

    Average:
    :   Adds the values together, then divides by 2.

    Minimum:
    :   Uses the smallest weight value of VGroup A’s or VGroup B’s weights.

    Maximum:
    :   Uses the largest weight value of VGroup A’s or VGroup B’s weights.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers,
see the [Vertex Weight Edit modifier](weight_edit.xhtml#modeling-modifiers-weight-edit-influence-mask-options) page.
user: Describe Metadata from the Blender manual or Python API, including usage steps and snippets.

assistant: # Metadata

[image reference removed]

Metadata panel.

The *Metadata* panel includes options for writing metadata into render output.

Metadata Input
:   Where to grab metadata from.

    Scene:
    :   Use metadata from the current scene.

    Sequencer Strips:
    :   Use metadata from the strips in the Sequencer.

Include
:   Date
    :   Includes the current date and time.

    Time
    :   Includes the current scene time and render frame at `HH:MM:SS.FF`.

    Render Time
    :   Includes the render time.

    Frame
    :   Includes the frame number.

    Frame Range
    :   Includes the start and end frame numbers.

    Memory
    :   Includes the peak memory usage.

    Hostname
    :   Includes the rendering machine’s [hostname](https://en.wikipedia.org/wiki/Hostname).

    Camera
    :   Includes the name of the active camera.

    Lens
    :   Includes the name of the active camera’s lens value.

    Scene
    :   Includes the name of the active scene.

    Marker
    :   Includes the name of the last marker.

    Filename
    :   Includes the filename of the blend-file.

    Strip Name
    :   Includes the name of the foreground sequence strip.
user: Show practical ways to work with Sampling in a Blender add-on or script – include code.

assistant: Interpolation
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Provide the full official documentation entry for FunctionNodeAxisAngleToRotation(FunctionNode), preserving all code examples.

assistant: # FunctionNodeAxisAngleToRotation(FunctionNode)

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

*class* bpy.types.FunctionNodeAxisAngleToRotation(*FunctionNode*)
:   Build a rotation from an axis and a rotation around that axis

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Navigating the node editors is done with the use of both mouse movement and keyboard shortcuts.

Pan `MMB`
:   Move the view up, down, left and right.

Zoom `Ctrl`-`MMB`, `Wheel`
:   Move the camera forwards and backwards.

Frame Selected `NumpadPeriod`
:   Adjusts the zooms to fit only the selected nodes in the view.

Frame All `Home`
:   Adjusts the zoom to fit all nodes in the view.
user: Give a detailed overview of Attributes: syntax, arguments, return values, common patterns.

assistant: The *Attributes* panel displays the available data fields associated with each point in the point cloud.
These attributes define characteristics like point position, size, color, and motion.

Use the [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) interface to browse, create, edit, or remove attributes.

### Attribute Types

The following are common built-in attributes supported by point cloud objects:

| Name | Type | Domain | Description |
| --- | --- | --- | --- |
| `position` | *Vector* | *Point* | Stores the 3D coordinates of each point in the object’s local space. |
| `radius` | *Float* | *Point* | Defines the visual radius (size) of each point when rendered or displayed. |
| `color` | *Color* | *Point* | The display color of the point. Used in viewport rendering or shading. |
| `id` | *Integer* | *Point* | A unique identifier assigned to each point. Useful for persistent referencing. |
| `velocity` | *Vector* | *Point* | Indicates the directional movement and speed of the point (e.g., for simulations or motion blur). |

Custom Attributes
:   Custom attribute can be given to particles to hold a custom characteristic.

    Name
    :   The name of the attribute.

    Data Type
    :   The type of data to store in the attribute.

        Float:
        :   Floating-point value

        Integer:
        :   32-bit integer

        Vector:
        :   3D vector with floating-point values

        Color:
        :   RGBA color with floating-point precision

        Byte Color:
        :   RGBA color with 8-bit precision

        String:
        :   Text string

    Domain
    :   The type of element the attribute is stored in.
        Currently, attributes can only be stored per *Point*.
user: Explain NodesModifierPanel(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # NodesModifierPanel(bpy_struct)

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

*class* bpy.types.NodesModifierPanel(*bpy_struct*)
:   is_open
    :   Whether the panel is expanded or closed

        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