PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Side of Active from the Blender manual or Python API, including usage steps and snippets.

assistant: # Side of Active

With an active vertex, this tool will select all vertices in a specified direction.
It is similarly to the *Loop Inner-Region* tool in that it will fill select faces within its perimeters,
however, it is determined by direction and not by a closed loop.

Axis Mode
:   Determines the behavior of the selection.
    More information on this can be found in [Transform Orientations](../../../editors/3dview/controls/orientation.xhtml).

Axis Sign
:   Positive/Negative Axis
    :   Depending on which *Axis* is chosen, the selection will encompass the positive or negative axis
        starting from the active vertex outward.

    Aligned Axis
    :   Where *Positive and Negative Axis* select all vertices in a given direction,
        *Aligned Axis* will only select the vertices that are in-line with the active vertex.

[image reference removed]

While following along the X axis: (from left to right) active vertex, Aligned, Positive, and Negative.

Axis
:   Chooses the direction of the selection.

Threshold
:   The amount of influence the selection has outside the original perimeters.
    The higher the *Threshold* the more vertices will be selected.
user: Explain Project from View in complete detail according to the official Blender documentation.

assistant: Projects the selected faces onto the view plane. The UV map essentially becomes a wireframe picture
of the mesh, taken in the 3D Viewport at the current viewing angle. Use this option if you are using a picture
of a real object as a texture. You will get stretching in areas where the model recedes away from you.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Orthographic
:   Use an [Orthographic](../../../editors/3dview/navigate/projections.xhtml#bpy-ops-view3d-view-persportho) projection instead of Perspective.

Camera Bounds
:   Map the borders of the image that would be rendered through the current camera to the borders of the UV map.
    This option only has an effect when viewing the scene through the camera;
    see [Viewing the Active Camera](../../../editors/3dview/navigate/camera_view.xhtml#bpy-ops-view3d-view-camera).

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.xhtml), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.xhtml).

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: Describe Collisions from the Blender manual or Python API, including usage steps and snippets.

assistant: Quality
:   A general setting for how fine and good a simulation you wish.
    Higher numbers take more time but ensure less tears and penetrations through the hair.

Distance
:   The distance another object must get to the hair for
    the simulation to repel the hair out of the way.
    Smaller values might cause errors but provide some speed-up while
    larger will give unrealistic results if too large and can be slow.
    It is best to find a good in between value.

Impulse Clamping
:   Prevents explosions in tight and complicated collision situations
    by restricting the amount of movement after a collision.

Collision Collection
:   Only objects that are a part of this [Collection](../../../scene_layout/collections/index.xhtml)
    can collide with the hair. Note that these objects must also have Collision physics enabled.
user: How do I use EvaluateClosureNodeViewerPathElem(ViewerPathElem) in Blender? Include parameters, examples, warnings and best practices.

assistant: # EvaluateClosureNodeViewerPathElem(ViewerPathElem)

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

*class* bpy.types.EvaluateClosureNodeViewerPathElem(*ViewerPathElem*)
:   evaluate_node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe GeometryNodeReverseCurve(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeReverseCurve(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.GeometryNodeReverseCurve(*GeometryNode*)
:   Change the direction of curves by swapping their start and end data

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is BrushCapabilities(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BrushCapabilities(bpy_struct)

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

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

    has_overlay
    :   Type:
        :   boolean, default False, (readonly)

    has_random_texture_angle
    :   Type:
        :   boolean, default False, (readonly)

    has_smooth_stroke
    :   Type:
        :   boolean, default False, (readonly)

    has_spacing
    :   Type:
        :   boolean, default False, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Base Color
:   Diffuse surface color. For conductor materials (metals) it should be black.

Specular
:   Amount of specular reflection. Specifies facing (along normal)
    reflectivity. Conductor materials (metals) can have colored specular reflection.

Roughness
:   Specifies microfacet roughness of the surface for diffuse and specular reflection.

Emissive Color
:   Color of the emitted light. This light is added to the BSDF result.

Transparency
:   Transparency factor. This is the inverse of the alpha channel (1 - alpha) you find in an image.
    Use an Invert node to convert alpha to transparency.
    This will only have an effect if the material uses a blend mode other than opaque.

Normal
:   Controls the normals of the base layers.

Clear Coat
:   Extra white specular layer on top of others.
    This is useful for materials like car paint and the like.

Clear Coat Roughness:
:   Roughness of clear coat specular.

Clear Coat Normal
:   Controls the normals of the *Clear Coat* layer.

Ambient Occlusion
:   Amount of occlusion to apply to indirect lighting. Usually a bake ambient occlusion map.
    The final occlusion factor is the minimum of this input and the runtime ambient occlusion effect.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

There are many ways to select elements, and it depends on what *Mesh Select Mode*
you are in as to what selection tools are available.
First we will go through these modes and after that a look is taken at basic selection tools.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Closure
:   The closure to evaluate.
    This input expects a connection from a [Closure Zone](closure.html).
    If no closure is connected, the node operates in *pass-through mode* (see below).

### Interface

The node can define additional inputs manually, which are matched by name to the corresponding inputs of the connected
closure. When the closure is connected, these sockets automatically sync to reflect the closure’s defined interface.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Closures are useful when part of a node group’s logic should be user-defined.
For example, a terrain generator can use a closure to define tree placement:

- The [Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.html)
  node is placed where tree instances are distributed.
- A closure input is exposed on the group’s interface.
- A [Closure](../../../../interface/controls/nodes/types/utilities/closure/closure.html)
  node is connected defining any custom placement logic.

When the closure is evaluated, the contents of the connected node graph
are executed inside the context of the terrain generator.
This allows the generator to provide stable infrastructure
(e.g., scattering, masks, attributes) while users supply their own functional behavior.

[image reference removed]

A terrain generator node group using closures for custom tree placement.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Arc tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.html#grease-pencil-draw-common-options) for more information.

### Creating Arcs

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can tweak the arc using a single cyan manipulator (hand icon).
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to make a perfect arc,
use `Alt` to create the arc from a center point or `M` to flip.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel`
will increase or decrease the amount of points in the final arc.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_arc_example-01.png>   click and dragging the start point. | <../../../../_images/grease-pencil_modes_draw_tools_arc_example-02.png>   Tweaking arc with the manipulator. | <../../../../_images/grease-pencil_modes_draw_tools_arc_example-03.png>   The arc after confirming. |

### Extruding

Before confirming you can use `E` to extrude the end point of the arc
to generate multiple connected arcs.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-01.png>   End point extruding. | <../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-02.png>   Tweaking the last arc with the manipulator. | <../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-03.png>   The connected arcs after confirming. |
user: Provide the full official documentation entry for Combine Spherical Node, preserving all code examples.

assistant: # Combine Spherical Node

[image reference removed]

The *Combine Spherical* node converts spherical coordinates (R, Φ, Θ)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Spherical](../../../../modeling/geometry_nodes/utilities/vector/separate_spherical.html) node.

Spherical coordinates represent a point in 3D space by its distance from the origin,
horizontal rotation, and vertical inclination, which can be useful for constructing
radial or rotational patterns and generating coordinates on a sphere.
user: Explain BlendDataArmatures(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BlendDataArmatures(bpy_struct)

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

*class* bpy.types.BlendDataArmatures(*bpy_struct*)
:   Collection of armatures

    new(*name*)
    :   Add a new armature to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New armature data-block

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

    remove(*armature*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove an armature from the current blendfile

        Parameters:
        :   - **armature** ([`Armature`](bpy.types.Armature.html#bpy.types.Armature "bpy.types.Armature"), (never None)) – Armature to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this armature before deleting it (WARNING: will also delete objects instancing that armature data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this armature data
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this armature data

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: Selects all connected faces with a similar angle.

Sharpness
:   Select connected faces with a reference angle less than the value specified.

[image reference removed]

Looking at the image above, when at least one face is selected (as seen on the left),
*Linked Flat Faces* will select all connecting faces that lie
on the same or similar plane (as shown in the middle image).
If the corners are smoothed, those faces are no longer lined up with the selected faces.
At this point, increasing the *Sharpness* value in the tool options could include the smoothed faces.
user: Explain Bpy.Types.Datatransfermodifier in complete detail according to the official Blender documentation.

assistant: g the affected areas 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 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 Inherited Properties ¶ bpy_struct.id_data Modifier.name Modifier.type Modifier.show_viewport Modifier.show_render Modifier.show_in_editmode Modifier.show_on_cage Modifier.show_expanded Modifier.is_active Modifier.use_pin_to_last Modifier.is_override_data Modifier.use_apply_on_spline Modifier.execution_time Modifier.persistent_uid Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values Modifier.bl_rna_get_subclass Modifier.bl_rna_get_subclass_py Next DecimateModifier(Modifier) Previous DampedTrackConstraint(Constraint) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page DataTransferModifier(Modifier) DataTransferModifier DataTransferModifier.data_types_edges DataTransferModifier.data_types_loops DataTransferModifier.data_types_polys DataTransferModifier.data_types_verts DataTransferModifier.edge_mapping DataTransferModifier.invert_vertex_group DataTransferModifier.islands_precision DataTransferModifier.layers_uv_select_dst DataTransferModifier.layers_uv_select_src DataTransferModifier.layers_vcol_loop_select_dst DataTransferModifier.layers_vcol_loop_select_src DataTransferModifier.layers_vcol_vert_select_dst DataTransferModifier.layers_vcol_vert_select_src DataTransferModifier.layers_vgroup_select_dst DataTransferModifier.layers_vgroup_select_src DataTransferModifier.loop_mapping DataTransferModifier.max_distance DataTransferModifier.mix_factor DataTransferModifier.mix_mode DataTransferModifier.object DataTransferModifier.poly_mapping DataTransferModifier.ray_radius DataTransferModifier.use_edge_data DataTransferModifier.use_loop_data DataTransferModifier.use_max_distance DataTransferModifier.use_object_transform DataTransferModifier.use_poly_data DataTransferModifier.use_vert_data DataTransferModifier.vert_mapping DataTransferModifier.vertex_group DataTransferModifier.bl_rna_get_subclass() DataTransferModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Explain Shadows in complete detail according to the official Blender documentation.

assistant: - *Shadow Map Raytracing* can produce light leaking because of overlapping shadow casters.
  This can be mitigated by using lower [step count](../render_settings/sampling.xhtml#bpy-types-sceneeevee-shadow-step-count), enabling
  [jitter](../light_settings.xhtml#bpy-types-light-use-shadow-jitter), or reducing the light shape size.
- Thin objects (e.g. walls without thickness) might have light leaking on the shadowed side.
  This can be mitigated by making the object have some thickness or lowering
  [Resolution Limit](../light_settings.xhtml#bpy-types-light-shadow-maximum-resolution).
user: Give a detailed overview of TextureNodeTexMarble(TextureNode): syntax, arguments, return values, common patterns.

assistant: # TextureNodeTexMarble(TextureNode)

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

*class* bpy.types.TextureNodeTexMarble(*TextureNode*)
:   *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 NodeSocketBool(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   boolean, default False

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

assistant: # Introduction

Cloth simulation is one of the hardest aspects of computer graphics,
it is a deceptively simple real-world item that is taken for granted,
but it actually has very complex internal and environmental interactions.
Cloth is commonly modeled as 2D mesh to simulate real world objects such as fabrics, flags, banners.
And yet cloth can also be used to model 3D objects such as teddy bears, pillows, balloons, or balls.

Cloth interacts with and is affected by other moving objects,
the wind and other forces, as well as a general aerodynamic model,
all of which is under your control.

|  |  |  |
| --- | --- | --- |
| ../../_images/physics_cloth_introduction_example1.jpg   Cloth example. | ../../_images/physics_cloth_introduction_oncarved-wood.jpg   Cloth on carved wooden men (made by motorsep). | ../../_images/physics_cloth_introduction_example2.jpg   Cloth example. |

Once Cloth physics have been added to a mesh, a [Cloth Modifier](../../modeling/modifiers/physics/cloth.xhtml)
will be added to the object’s modifier stack. As a modifier then,
it can interact with other modifiers, such as *Armature* and *Smooth*. In these cases,
the ultimate shape of the mesh is computed in accordance with the order of the modifier stack.
For example, you should smooth the cloth *after* the modifier computes the shape of the cloth.

You can *Apply* the Cloth Modifier to freeze, or lock in,
the shape of the mesh at that frame, which removes the modifier. For example,
you can drape a flat cloth over a table, let the simulation run, and then apply the modifier.
In this sense, you are using the simulator to save yourself a lot of modeling time.

Results of the simulation are saved in a cache, so that the shape of the mesh,
once calculated for a frame in an animation, does not have to be recomputed again.
If changes to the simulation are made, you have full control over clearing the cache and re-running the simulation.
Running the simulation for the first time is fully automatic and no baking or separate step interrupts the workflow.

Computation of the shape of the cloth at every frame is automatic and done in the background;
thus you can continue working while the simulation is computed. However, it is CPU-intensive
and depending on the power of your PC and the complexity of the simulation,
the amount of CPU needed to compute the mesh varies, as does the lag you might notice.
user: Provide the full official documentation entry for Adaptive Domain, preserving all code examples.

assistant: # Adaptive Domain

When enabled, the domain will adaptively shrink to best fit the gas,
saving computation time by leaving voxels without gas out of the simulation.
Unless the *Add Resolution* is used, the adaptive domain will not exceed the bounds of the original domain.

Add Resolution
:   Number of voxels to add around the outside of the domain.

Margin
:   Amount of extra space to leave around gas, measured in voxels.
    With very fast-moving gas larger margins may be required to prevent the gas from being cut off
    by the adaptive boundary, but note this will increase the number of voxels which need to be computed.

Threshold
:   Smallest amount of gas a voxel can contain before it is considered empty
    and the adaptive domain is allowed to cut it out of the simulation.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`Text.current_line`](bpy.types.Text.html#bpy.types.Text.current_line "bpy.types.Text.current_line") - [`Text.lines`](bpy.types.Text.html#bpy.types.Text.lines "bpy.types.Text.lines") | - [`Text.select_end_line`](bpy.types.Text.html#bpy.types.Text.select_end_line "bpy.types.Text.select_end_line") |
user: Explain Color Key Node in complete detail according to the official Blender documentation.

assistant: # Color Key Node

[image reference removed]

The *Color Key* node is used for chroma keying—removing parts of an image based on color.
It is commonly used to remove backgrounds like green screens or blue screens from footage,
creating a matte where selected colors become transparent.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Stretch To constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to stretch towards.

Original Length
:   The rest distance between owner and target, i.e.
    the distance at which there is no stretching of the owner.

    (Reset Original Length)
    :   Sets the *Original Length* to the current distance between owner and target.

Volume Variation
:   Exponent that either exaggerates (> 1) or reduces (< 1) the thickness change caused
    by volume preservation. Setting this to 0 is the same as setting *Maintain Volume* to
    *None*.

Volume Min, Max
:   Lower and upper limits for the thickness factor applied by volume preservation.

    If *Maintain Volume* is set to XZ, the X and Z factors are each bound to the square
    root of these limits. For example, if *Volume Max* is set to 4, both the X and Z scale
    can grow to no more than twice their original value.

    If *Maintain Volume* is set to X or Z, the factor for the chosen axis is bound to these
    limits. In the above example, the axis could grow to no more than 4 times its original value
    (while the other axis would not grow or shrink at all).

Smooth
:   A higher value will slow down the thickness change as it approaches the limits.
    This prevents an abrupt stop once the limits are reached.

Maintain Volume
:   Whether to make the owner thicker/thinner as it contracts/stretches to meet the target.

    XZ:
    :   Scale along both the X and Z axes.

    X:
    :   Scale along the X axis only.

    Z:
    :   Scale along the Z axis only.

    None:
    :   Don’t change the X and Z scales.

Rotation
:   How the owner should be rotated to track the target with its Y axis.

    XZ:
    :   Tries to keep the local X axis close to its original orientation.

    ZX:
    :   Tries to keep the local Z axis close to its original orientation.

    Swing:
    :   Uses a [swing](../../../glossary/index.xhtml#term-Swing) rotation, much like the [Damped Track Constraint](damped_track.xhtml).

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

assistant: # GeometryNodeInputActiveCamera(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.GeometryNodeInputActiveCamera(*GeometryNode*)
:   Retrieve the scene’s active camera

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Corner Angle
:   The internal angle at each face corner, measured in radians.
    For example, a right angle returns approximately `1.571`.

Bisector
:   A normalized vector pointing along the bisector of the corner angle,
    halfway between the directions of the two connected edges.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Vertex Weight Angle modifier panel.

Vertex Group
:   The vertex group to affect.

    Invert
    :   Inverts the influence of the selected vertex group. The setting reverses the weight values of the group.

Angle
:   Sets the angle for the maximum weights value.

Axis
:   The axis along which the angle affects the weights.

    X, Y, Z

Space
:   Coordinate space to be used.

Minimum
:   Minimum value for vertex weight.

Multiply Weights
:   Multiply the calculated weights with the existing values in the vertex group.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Creating a Kernel in the Compositor, preserving all code examples.

assistant: Kernels can be created directly inside the compositor using Blender’s existing nodes,
without the need for an external image.

This approach is useful for designing procedural or parameterized filters, blurs,
and glare patterns that can be modified interactively.

1. **Start with a Constant Image**
   Use an [Image Node](types/input/image.html) set to a small resolution,
   such as 9x9 or 15x15 pixels.
   Alternatively, generate a solid color using a [RGB](types/input/constant/rgb.html) node.
2. **Shape the Kernel**
   Modify the pixel values to define the kernel weights:

   - Use the [Ellipse Mask](types/mask/ellipse_mask.html) or
     [Blur](types/filter/blur/blur.html) nodes to create soft, circular falloffs.
   - Combine multiple masks with [Mix](types/color/mix_color.html) nodes to form
     complex or directional shapes (for example, a star or streak pattern).

   Scale the overall strength using a [Math](types/utilities/math/math.html) node
   in *Multiply* mode, or normalize the kernel values by dividing by their total sum.
3. **Feed into the Convolve Node**
   Connect the resulting procedural image to the *Kernel* input of the
   [Convolve Node](types/filter/convolve.html).
   The pattern and brightness of this image directly control the convolution effect.

### Tips

- Small images (under 20x20 pixels) produce efficient, responsive kernels.
- Use *Normalize Kernel* in the *Convolve* node to maintain brightness balance automatically.
- Animated masks or procedural noise patterns can be used to create dynamic or flickering filter effects.
- Kernels with positive and negative values can be used to emphasize edges or textures.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`GizmoGroup.gizmos`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.gizmos "bpy.types.GizmoGroup.gizmos") - [`GizmoGroup.invoke_prepare`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.invoke_prepare "bpy.types.GizmoGroup.invoke_prepare") | - [`Gizmos.new`](bpy.types.Gizmos.html#bpy.types.Gizmos.new "bpy.types.Gizmos.new") - [`Gizmos.remove`](bpy.types.Gizmos.html#bpy.types.Gizmos.remove "bpy.types.Gizmos.remove") |
user: Give a detailed overview of CPU Rendering: syntax, arguments, return values, common patterns.

assistant: Being a rasterization engine, EEVEE only uses the power of
the GPU to render.
There is no plan to support CPU (software) rendering
as it would be very inefficient. CPU power is still needed to handle high scene complexity
as the geometry must be prepared by the CPU before rendering each frame.
user: Give a detailed overview of Voronoi: syntax, arguments, return values, common patterns.

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: Explain Template Contents in complete detail according to the official Blender documentation.

assistant: Each of the following files can be used for application templates but are optional.

`startup.blend`
:   Factory startup file to use for this template.

`userpref.blend`
:   Factory preferences file to use for this template.
    When omitted preferences are shared with the default Blender configuration.

    *(As noted previously, this is only used for a subset of preferences).*

`splash.png`
:   Splash screen to override Blender’s default artwork (not including header text).
    Note, this image must be a `1000x500` image.

`__init__.py`
:   A Python script which must contain `register` and `unregister` functions.
user: Give a detailed overview of Unwrap: syntax, arguments, return values, common patterns.

assistant: Blender offers several ways of mapping UVs.
The simpler projection methods use formulas that map 3D space onto 2D space,
by interpolating the position of points toward a point, axis or plane through a surface.
The more advanced methods can be used with more complex models, and have more specific uses.

- [Unwrap](../editing/uv.xhtml#bpy-ops-uv-unwrap)
- [Smart UV Project](../editing/uv.xhtml#bpy-ops-uv-smart-project)
- [Lightmap Pack](../editing/uv.xhtml#bpy-ops-uv-lightmap-pack)
- [Follow Active Quads](../editing/uv.xhtml#bpy-ops-uv-follow-active-quads)
- [Cube Projection](../editing/uv.xhtml#bpy-ops-uv-cube-project)
- [Cylinder Projection](../editing/uv.xhtml#bpy-ops-uv-cylinder-project)
- [Sphere Projection](../editing/uv.xhtml#bpy-ops-uv-sphere-project)
user: Describe Blender 3 from the Blender manual or Python API, including usage steps and snippets.

assistant: - [Blender 3.6 LTS](https://docs.blender.org/manual/en/3.6/)
- [Blender 3.5](https://docs.blender.org/manual/en/3.5/)
- [Blender 3.4](https://docs.blender.org/manual/en/3.4/)
- [Blender 3.3 LTS](https://docs.blender.org/manual/en/3.3/)
- [Blender 3.2](https://docs.blender.org/manual/en/3.2/)
- [Blender 3.1](https://docs.blender.org/manual/en/3.1/)
- [Blender 3.0](https://docs.blender.org/manual/en/3.0/)
user: Explain Separate Bundle Node in complete detail according to the official Blender documentation.

assistant: # Separate Bundle Node

[image reference removed]

The *Separate Bundle* node extracts individual values from a
[Bundle](../../../../interface/controls/nodes/types/utilities/bundles/index.xhtml).
Each output corresponds to an element in the bundle, identified by its socket name.

This node is the counterpart of the
[Combine Bundle](../../../../interface/controls/nodes/types/utilities/bundles/combine_bundle.xhtml)
node and is typically used to retrieve structured data that was previously grouped together.
user: Show practical ways to work with Snapping in a Blender add-on or script – include code.

assistant: # Snapping

Snapping lets you easily align UV elements to others.
It can be toggled by clicking the magnet icon in the UV Editor’s header,
or more temporarily by holding `Ctrl`.

This page is about the Snap header button; for the Snap menu,
see [UV Editing](../../../modeling/meshes/uv/editing.xhtml#bpy-ops-uv-snap-selected).
user: Describe CurveSplines(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CurveSplines(bpy_struct)

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

*class* bpy.types.CurveSplines(*bpy_struct*)
:   Collection of curve splines

    active
    :   Active curve spline

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

    new(*type*)
    :   Add a new spline to the curve

        Parameters:
        :   **type** (enum in [`'POLY'`, `'BEZIER'`, `'NURBS'`]) – type for the new spline

        Returns:
        :   The newly created spline

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

    remove(*spline*)
    :   Remove a spline from a curve

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

    clear()
    :   Remove all splines from a curve

    *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 Erase Lasso: syntax, arguments, return values, common patterns.

assistant: The *Erase Lasso* operator erases all Grease Pencil strokes within a freeform selection.

- Press and hold `Ctrl`-`Alt`-`RMB`, then draw a lasso shape around the area you want to erase.
- Release the mouse button to apply the eraser.
- Only points within the lasso region are removed.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Scenes are a way to organize your work. Each blend-file can contain multiple scenes,
which may share other data such as objects, materials, and collections.

A scene defines the visible objects, camera view, lighting setup,
and render settings that make up a specific part of a project.
For example, a single blend-file may include multiple scenes for different shots,
lighting setups, or stages of a production pipeline.

Scene management and library linking are based on Blender’s
[Library and Data System](../../files/index.html).
If you are not familiar with the concepts of data-blocks, linking, and appending,
it is recommended to read that page first.
user: Describe Troubleshooting Linux – NVIDIA from the Blender manual or Python API, including usage steps and snippets.

assistant: # Troubleshooting Linux – NVIDIA

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: How do I use Built-In Attributes in Blender? Include parameters, examples, warnings and best practices.

assistant: Built-in attributes always exist, and cannot be removed. Their data type and domain cannot be changed.

| Name | Type | Domain | Notes |
| --- | --- | --- | --- |
| `position` | *Vector* | *Point* | Built-in attribute describing vertex or point locations, in the local space of a geometry. Any node that changes the location of points will adjust this attribute, like the [Transform Geometry Node](geometry/operations/transform_geometry.html) and the [Set Position Node](geometry/write/set_position.html). |
| `radius` | *Float* | *Point* | A built-in attribute on point clouds used to set the size for the points in the viewport. Also built-in on curves, where it controls the size of each curve control point when converted to a mesh, or for other operations. |
| `id` | *Integer* | *Point* | Created by the [Distribute Points on Faces](point/distribute_points_on_faces.html) to provide stability when the shape of the input mesh changes, and used on instances to create motion blur. Values are expected to be large, with no order. This attribute is used by nodes that generate randomness, like the [Random Value Node](utilities/random_value.html). Unlike other built-in attributes, this attribute is not required, and can be removed. |
| `material_index` | *Integer* | *Face* | Used to specify the material slot for every face in a mesh. |
| `sharp_edge` | *Boolean* | *Edge* | Attribute determining if an edge should have flat (rather than smooth) shading enabled in the viewport or a render. |
| `sharp_face` | *Boolean* | *Face* | Attribute determining if a face should have flat (rather than smooth) shading enabled in the viewport or a render. |
| `resolution` | *Integer* | *Spline* | Determines the number of evaluated points between two control points of a spline. Only NURBS and Bézier splines have this attribute, for poly splines, the value is always one. |
| `cyclic` | *Boolean* | *Spline* | Determines whether the spline has a segment that connects its first and last control points. |
| `handle_left` | *Vector* | *Point* | Describes the location of the left handle of a curve control point, on the side of the curve’s start. Only exists when the curve contains a Bézier spline. |
| `handle_right` | *Vector* | *Point* | Describes the location of the right handle of a curve control point, on the side of the curve’s end. Only exists when the curve contains a Bézier spline. |
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

The Mesh to Volume modifier.

Object
:   The mesh object that determines where the volume data will be generated.

Density
:   Makes the generated volume appear denser or less dense when rendering.

Interior Band Width
:   The maximum distance of the included voxels to the surface on the inside of the mesh.

Resolution Mode
:   Mode for how the voxel size is specified.

    Voxel Amount:
    :   This allows setting an approximate number of voxels that will be used to represent mesh along its diagonal.
        When the dimensions of the mesh changes, the voxel size will change as well.
        For final rendering of animations, it’s better to specify the voxel size explicitly to avoid artifacts.

    Voxel Size:
    :   This allows setting the exact voxel size that will be used.
        This is idea for rendering when the voxel size should not change between frames.
user: Show practical ways to work with Volume Cube Node in a Blender add-on or script – include code.

assistant: # Volume Cube Node

[image reference removed]

The *Volume Cube* generates a volume by evaluating a density field on a 3D grid.
The *Density* field can only depend on the [Position Node](../../geometry/read/position.xhtml).
The grid points are equally spaced between the *Min* and *Max* bounds of the grid.
user: Provide the full official documentation entry for Documentation, preserving all code examples.

assistant: - [Quickstart](info_quickstart.html): New to Blender or scripting and want to get your feet wet?
- [API Overview](info_overview.html): A more complete explanation of Python integration.
- [API Reference Usage](info_api_reference.html): Examples of how to use the API reference docs.
- [Best Practice](info_best_practice.html): Conventions to follow for writing good scripts.
- [Tips and Tricks](info_tips_and_tricks.html): Hints to help you while writing scripts for Blender.
- [Gotchas](info_gotcha.html): Some of the problems you may encounter when writing scripts.
- [Advanced](info_advanced.html): Topics which may not be required for typical usage.
- [Change Log](change_log.html): List of changes since last Blender release