PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Writing Shaders and how is it used in Blender Python scripting?

assistant: For more details on how to write shaders, see the
[OSL Documentation](https://open-shading-language.readthedocs.io/en/latest/).

Here is a simple example:

```
shader simple_material(
    color Diffuse_Color = color(0.6, 0.8, 0.6),
    float Noise_Factor = 0.5,
    output closure color BSDF = diffuse(N))
{
    color material_color = Diffuse_Color * mix(1.0, noise(P * 10.0), Noise_Factor);
    BSDF = material_color * diffuse(N);
}
```
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Lattice modifier example.

|  |  |
| --- | --- |
| <../../../_images/grease-pencil_modifiers_deform_lattice_original.png>   Original model. | <../../../_images/grease-pencil_modifiers_deform_lattice_edit.png>   After lattice editing. |
user: Show practical ways to work with MeshSequenceCacheModifier(Modifier) in a Blender add-on or script – include code.

assistant: # MeshSequenceCacheModifier(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.MeshSequenceCacheModifier(*Modifier*)
:   Cache Mesh

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

    object_path
    :   Path to the object in the Alembic archive used to lookup geometric data

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

    read_data
    :   Data to read from the cache

        Type:
        :   enum set in {`'VERT'`, `'POLY'`, `'UV'`, `'COLOR'`, `'ATTRIBUTES'`}, default {`'ATTRIBUTES'`, `'COLOR'`, `'POLY'`, `'UV'`, `'VERT'`}

    use_vertex_interpolation
    :   Allow interpolation of vertex positions

        Type:
        :   boolean, default True

    velocity_scale
    :   Multiplier used to control the magnitude of the velocity vectors for time effects

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: These overlays are available when a [Grease Pencil](../../../grease_pencil/index.html) object is selected.

Onion Skin
:   Show ghosts of the keyframes before and after the current frame.
    If [Multiframe](../../../grease_pencil/multiframe.html) is enabled,
    ghosts of the selected keyframes are shown instead.
    See [Onion Skinning](../../../grease_pencil/properties/onion_skinning.html).

Active Object Only
:   Show only the onion skins of the active object.

Fade Inactive Layers
:   Decrease the opacity of all the layers in the object other than the active one.
    The opacity factor can be controlled with the slider.

Fade Inactive Objects
:   Cover all of the viewport except the active Grease Pencil object with a full color layer to improve visibility
    while drawing over complex scenes.

    Fade Grease Pencil Objects
    :   Include or exclude Grease Pencil objects.

Edit Lines Edit, Sculpt, Weight Paint, or Vertex Paint Modes `Shift`-`Q`
:   Shows a line between points on top of other geometry when editing strokes.

Only in Multiframe `Shift`-`Alt`-`Q`
:   When Multiframe is enabled and keyframes other than the current frame are selected,
    strokes on those keyframes are displayed as just their edit lines – the strokes themselves are hidden.
    Note that this does not affect Onion Skinning.

Handles
:   Controls the visibility of Bézier curve handles in edit mode.

    None:
    :   Hides all Bézier curve handles, providing an unobstructed view of the curve.

    Selected:
    :   Displays the handles only for selected control points.

    All:
    :   Displays the handles for all control points in the curve.

Stroke Direction Edit
:   Toggle the display of the selected strokes’ start points (green) and end points (red) to visualize their direction.

Material Name Edit
:   Show material name next to the selected strokes.

Vertex Paint

Vertex Paint Opacity Vertex Paint
:   The opacity of the vertex color overlay in Vertex Paint Mode and Draw Mode.
    Note that in Draw Mode, vertex paint is only visible in the *Material Preview*
    and *Rendered* shading modes by default. To see it in *Solid* mode, you either
    need to use Vertex Paint Mode, or set the [Color](../../../render/workbench/color.html)
    shading setting to *Attribute*.

### Canvas

Display a grid over the Grease Pencil drawing plane.

Canvas Grid Opacity
:   The opacity of the grid.

Canvas X-Ray
:   Objects are drawn behind the canvas grid.

Subdivisions
:   The number of subdivisions between grid lines.

Grid Color
:   The color of the grid lines.

Scale X/Y
:   The horizontal/vertical size of the grid.

Offset X/Y
:   The amount to shift the grid up/down and left/right.
user: Provide the full official documentation entry for Crash on Startup, preserving all code examples.

assistant: Try running Blender from the [command line](../../../advanced/command_line/index.xhtml), to see if any helpful error messages
are printed.

On Windows, graphics drivers can sometimes get corrupted or incorrectly replaced by Windows Update. In this case, it
can help to uninstall all graphics drivers (there may be multiple sets installed from Intel, AMD and NVIDIA) and
perform a clean installation with drivers from the manufacturer’s website.
user: What is Usage and how is it used in Blender Python scripting?

assistant: First, select the tool in the Toolbar or press `K`. The cursor
will change into a scalpel to indicate it’s active.

Click `LMB` at the place where you want to start cutting.
This can be anywhere: on an existing vertex, edge or face,
or even outside of the mesh.

Move your mouse to the next location. You’ll see a purple line indicating
the new edges that will be created, and green squares indicating the new
vertices. Click `LMB` to confirm: the green squares will turn red,
and you can define the next line in the cutting path.

Once you’re done, press `Spacebar` or `Return` to apply the cuts.
Alternatively, press `Esc` to cancel.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_tools_knife_line-before.png   Mesh before knife cut. | ../../../../_images/modeling_meshes_tools_knife_line-active.png   Knife cut active. | ../../../../_images/modeling_meshes_tools_knife_line-after.png   After applying knife cut. |
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`BlendData.shape_keys`](bpy.types.BlendData.html#bpy.types.BlendData.shape_keys "bpy.types.BlendData.shape_keys") - [`Curve.shape_keys`](bpy.types.Curve.html#bpy.types.Curve.shape_keys "bpy.types.Curve.shape_keys") | - [`Lattice.shape_keys`](bpy.types.Lattice.html#bpy.types.Lattice.shape_keys "bpy.types.Lattice.shape_keys") - [`Mesh.shape_keys`](bpy.types.Mesh.html#bpy.types.Mesh.shape_keys "bpy.types.Mesh.shape_keys") |
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Mesh
:   Standard geometry input.

Selection
:   Boolean field that controls which faces will have the Face Set value applied.

Face Set
:   Integer field for specifying which face set each selected face should be moved to.
    Ignored for faces where the value of Selection is false.
user: Give a detailed overview of Select Menu: syntax, arguments, return values, common patterns.

assistant: The Select menu lets you select strips in different ways.

All `A`
:   Selects all the strips in the timeline.

None `Alt`-`A`
:   Deselects all the strips in the timeline.

Invert `Ctrl`-`I`
:   Inverts the current selection.

Box Select `B`
:   See [Box Select](../../../interface/selecting.html#bpy-ops-select-box).

Box Select (Include Handles) `Ctrl`-`B`
:   Works like *Box Select*, but also selects any strip handles inside the box. If a strip has only
    one handle selected, dragging it will change the strip’s length. (If both handles are selected,
    the complete strip moves instead.)

Select Grouped `Shift`-`G`
:   Select strips that are similar to the active strip. By default, unsimilar strips are
    deselected, but this can be changed in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last)
    region.

    Type
    :   Select strips that have the same specific type as the active strip. For example,
        if the active strip is a Movie strip, this selects all Movie strips.

    Global Type
    :   Select strips that have the same general type (graphics or audio) as the active strip.

    Effect Type
    :   If the active strip is an effect strip, selects all effect strips. Otherwise,
        selects all non-effect strips. (Despite the name, this operator does not check
        the effect type.)

    Data
    :   Select strips that use the same source (file, scene, movie clip or mask) as the active strip.

    Effect
    :   Find the effect types that are applied to the active strip, and select all strips that have
        any of the same effect types applied to them. For example, if the active strip has a
        Gaussian Blur effect on it, this will select all other strips that are also blurred.

    Effect/Linked
    :   Select strips that are on a lower channel than a selected strip and overlap it in time;
        then, effect strips linked to the selected content strips; and finally, content strips
        linked to the selected effect strips.

    Overlap
    :   Select strips that partially or completely overlap the active strip in time.

Select Linked
:   All `Ctrl`-`L` / Less `Ctrl`-`NumpadMinus` / More `Ctrl`-`NumpadPlus`
    :   Add/remove neighboring strips to/from the selection.

Side of Frame
:   Left/Right `[`/`]`
    :   Select the strips that lie completely to the left or right of the current frame.

    Current
    :   Select the strips that intersect the current frame.

Handle
:   Both, Left, Right
    :   Select the left, right, or both handles of the selected strips.

    Both/Left/Right Neighbor
    :   Select the handle of the neighboring strip to the left, right, or on both sides of the selected strips.

Channel
:   Select all the strips that are in the same channels as the currently selected strips.
user: Provide the full official documentation entry for GeometryNodeCurvePrimitiveQuadrilateral(GeometryNode), preserving all code examples.

assistant: # GeometryNodeCurvePrimitiveQuadrilateral(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.GeometryNodeCurvePrimitiveQuadrilateral(*GeometryNode*)
:   Generate a polygon with four points

    mode
    :   - `RECTANGLE`
          Rectangle – Create a rectangle.
        - `PARALLELOGRAM`
          Parallelogram – Create a parallelogram.
        - `TRAPEZOID`
          Trapezoid – Create a trapezoid.
        - `KITE`
          Kite – Create a Kite / Dart.
        - `POINTS`
          Points – Create a quadrilateral from four points.

        Type:
        :   enum in [`'RECTANGLE'`, `'PARALLELOGRAM'`, `'TRAPEZOID'`, `'KITE'`, `'POINTS'`], default `'RECTANGLE'`

    *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 Creating Extensions and how is it used in Blender Python scripting?

assistant: # Creating Extensions

Extensions are **add-ons** or **themes** used to extend the core functionality of Blender.
They are shared in online platforms, and can be installed and updated from within Blender.

The official extensions platform for the Blender project is [extensions.blender.org](https://extensions.blender.org).
Other third party sites can also be supported, as long as they follow the Extensions Platform specification.
user: How do I use Screw in Blender? Include parameters, examples, warnings and best practices.

assistant: # Screw

The *Screw* operator extrudes geometry along a helix. You can use it to create screws, springs,
sea shells and so on.

While it’s similar to the [Screw Modifier](../../../modifiers/generate/screw.html),
there are some important differences:

| Screw operator | Screw modifier |
| --- | --- |
| Works in world space. | Works in object space. |
| Extrudes only the selected geometry. | Extrudes all geometry. |
| The centerpoint can be specified manually. | The centerpoint is always the object’s origin. |
| One revolution is always 360°. | The angle can be chosen freely. |
| The height offset of each revolution is calculated automatically based on the geometry. | The height offset must be specified manually. |
| Each revolution can also have a radial offset away from/towards the central axis (again determined by the geometry). | The radius stays constant. |

As described above, the Screw operator automatically determines the height offset and radial
offset to apply after each revolution. It does this by looking for the endpoints of an open profile –
a series of connected edges that don’t form a closed loop. The geometry is extruded so that the
profile’s top vertex in one revolution will coincide with the bottom vertex in the next.

The most common use case is extruding such an open profile. You’re not limited to this, however.
As long as there is one open profile in the selection – even just a single loose edge –
you can also extrude closed profiles and even geometry with faces.

You can see some examples below.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_screw_example-shell.png   Wood Screw. | ../../../../_images/modeling_meshes_editing_edge_screw_example-spring.png   Spring. |
user: What is Geometry to Instance Node and how is it used in Blender Python scripting?

assistant: # Geometry to Instance Node

[image reference removed]

The *Geometry to Instance* node turns every connected input geometry into an instance.
Visually, the node has a similar result as the [Join Geometry Node](join_geometry.xhtml),
but it outputs the result as separate instances instead. The geometry data itself isn’t actually
joined.

The node can be used in combination with the *Pick Instances* option in the
[Instance on Points Node](../instances/instance_on_points.xhtml), as a way to pick
between geometry generated in the node tree (as opposed to picking from separate
instances from the [Collection Info Node](../input/scene/collection_info.xhtml), for example).
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Next Edge Index
:   The index of the neighboring edge in the face, in the direction of increasing face corner indices.

Previous Edge Index
:   The index of the neighboring edge in the face, in the direction of decreasing face corner indices.
user: How do I use Springs in Blender? Include parameters, examples, warnings and best practices.

assistant: Internally, cloth physics is simulated with virtual springs that connect the vertices of a mesh.
There are four types of springs that control how the cloth bends.
These four types are defined below and illustrated in the following image:

[image reference removed]

Illustration of cloth springs; tension springs (blue),
compression springs (red), shear springs (cyan),
and angular bending springs (green).

Tension Springs
:   Control the stiffness of the cloth.

Compression Springs
:   Control the amount of force required to collapse or compress the cloth.

Shear Springs
:   Like compression springs but it controls the angular deformation.

Angular Bending Springs
:   Control how resilient the cloth is to folding or crumpling.

All four of these spring types can be controlled independently in
the [Physical Properties](settings/physical_properties.xhtml) panel. While these settings
control surface springs, optionally, internal springs can be used for 3D meshes
and behave similarly to [Soft Bodies](../soft_body/index.xhtml).
user: Show practical ways to work with NodeTreeInterfaceSocketVectorPercentage(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketVectorPercentage(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.NodeTreeInterfaceSocketVectorPercentage(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Brush Settings in complete detail according to the official Blender documentation.

assistant: ### General

Only Size and Auto-Masking has an impact on the brush behavior for this brush.

### Unique

Deformation
:   Deformation type that is used by the brush.

    Rotate/Twist:
    :   Rotates the mesh around the pose origin.
        When pressing `Ctrl`, the brush applies a twist rotation
        instead (and disables any IK segments that are used).

    Scale/Translate:
    :   Scale the mesh based on the pose origin.
        While holding `Ctrl` the brush moves the mesh.

    Squash/Stretch:
    :   Works similar to *Scale/Translate* however, it applies different
        scale values along different axes to achieve the stretching effect.

Rotation Origins
:   Method to set the rotation origin for the pose origin or individual IK segments.

    Topology:
    :   Sets the rotation origin automatically using the topology and shape of the mesh.

    Face Sets:
    :   Creates a pose segment per [Face Set](../editing/face_sets.html#sculpting-editing-facesets), starting from the active face set.
        This can lead to the most accurate and desirable results.

    Face Sets FK:
    :   Simulates a [Forward Kinematics](../../../glossary/index.html#term-Forward-Kinematics) deformation using the [Face Set](../editing/face_sets.html#sculpting-editing-facesets)
        under the cursor as control.

Pose Origin Offset
:   Offset of the pose origin in relation to the brush radius.
    This is useful to manipulate areas with a lot of complex shapes like fingers.

Smooth Iterations
:   Controls the smoothness of the falloff of the deformation.

Pose IK Segments
:   Controls how many [IK segments](../../../animation/armatures/posing/bone_constraints/inverse_kinematics/introduction.html#bone-constraints-inverse-kinematics)
    are going to be created for posing.
    This can be seen by a divided white line on the cursor.
    This is also useful for making curved deformations with the pose brush,
    like hair clumps and tails.

Lock Rotation when Scaling
:   When using *Scale/Translate Deformation*, do not rotate the segment; only scaling is applied.

Keep Anchor Point
:   Keeps the position of the last segment in the IK chain fixed.
    If this is disabled, the mesh can be dragged around more freely,
    creating snake like shapes.

Connected Only
:   The brush will only affect topologically connected elements.
    Disabling this will allow deforming multiple disconnected meshes at the same time,
    for example characters with clothing & shoes.

    Disabling this setting can have a big impact on performance,
    as neighboring elements will be merged internally.
    Keeping the *Max Element Distance* as low as possible
    will help counteract the performance impact.

Max Element Distance
:   Maximum distance to search for disconnected loose parts in the mesh.
user: Describe Video Sequencer from the Blender manual or Python API, including usage steps and snippets.

assistant: Memory Cache Limit
:   Upper limit of the Video Sequencer and Movie Clip Editor memory cache (in megabytes).
    For an optimal Clip editor and Sequencer performance, high values are recommended.

Proxy Setup
:   When and how [Proxies](../video_sequencer/sequencer/sidebar/proxy.html) are created.

    Automatic:
    :   Build proxies for added movie and image strips in each preview size.

    Manual:
    :   Set up proxies manually.
user: What is Image Menu and how is it used in Blender Python scripting?

assistant: Transform
:   Move Origin `Ctrl`-`Period`
    :   Moves the origin of the image strip without changing the strip’s content position.

        This is useful for adjusting the reference point for transformations like rotation, scaling, or further
        positioning. For example, shifting the origin to a corner of the image allows rotations to pivot around that
        corner, rather than the default center.

Clear
:   Resets the position, rotation, or scale of the selected images.

Apply
:   Scale to Fit
    :   Resizes the selected images so that they’re as large as possible while still
        fitting completely inside the video. They don’t get cropped, and their aspect ratio
        stays the same.

    Scale to Fill
    :   Resizes the selected images to that they fill the entire video space.
        They may get cropped, but their aspect ratio stays the same.

    Stretch to Fill
    :   Resizes the selected images to match the video dimensions.
        They don’t get cropped, but their aspect ratio may change.
user: How do I use Move to Layer in Blender? Include parameters, examples, warnings and best practices.

assistant: A pop-up menu to move the stroke to a different layer.
You can choose the layer to move the selected strokes to
from a list of layers of the current Grease Pencil object.
You can also add a new layer to move the selected stroke to.
When creating a new layer, there is another pop-up to type in the name of the new layer.
user: Explain GeometryNodeMeshToSDFGrid(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeMeshToSDFGrid(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.GeometryNodeMeshToSDFGrid(*GeometryNode*)
:   Create a signed distance volume grid from a mesh

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

assistant: |  |  |
| --- | --- |
| - [`SoundEqualizerModifier.graphics`](bpy.types.SoundEqualizerModifier.html#bpy.types.SoundEqualizerModifier.graphics "bpy.types.SoundEqualizerModifier.graphics") | - [`SoundEqualizerModifier.new_graphic`](bpy.types.SoundEqualizerModifier.html#bpy.types.SoundEqualizerModifier.new_graphic "bpy.types.SoundEqualizerModifier.new_graphic") |
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Text wrapped around logo.

This was made by creating the Blender logo and text as separate objects.
The text was converted to a mesh and then warped around the Blender logo.
user: What is Split and how is it used in Blender Python scripting?

assistant: The *Split* operator separates the selected portion of a curve from the rest,
creating a new, independent curve segment.
This curve can then be moved or altered without affecting the other curve.

- If a segment of the curve is selected, it will be split off
  as a new curve that can be moved or edited independently.
- If only a single control point is selected, it will be duplicated as a loose control point,
  while the original remains attached to the rest of the curve.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Blur Visual Effect.

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

Use Depth of Field
:   When enabled, the blur effect uses the focal plane distance of the actual camera to
    calculate the object blur. Only available in camera view.

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

Rotation
:   Control the Rotation of the blur.
user: What is Attributes and how is it used in Blender Python scripting?

assistant: When merging attributes from multiple geometry inputs, the highest complexity data type is chosen
for the output attribute. For example, if a `weight` attribute is a Boolean on one geometry input
and a vector on another, the `weight` attribute on the output geometry will use the vector data type.

Named and anonymous attributes are propagated from the [instance domain](../attributes_reference.xhtml#attribute-domains)
to the realized geometry. If an attribute exists both on the base geometry and on an instance,
the attribute values from the base geometry take precedence.
user: How do I use Bpy.Types.Spacegrapheditor in Blender? Include parameters, examples, warnings and best practices.

assistant: et_subclass Space.bl_rna_get_subclass_py Space.draw_handler_add Space.draw_handler_remove Next SpaceImageEditor(Space) Previous SpaceFileBrowser(Space) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page SpaceGraphEditor(Space) SpaceGraphEditor SpaceGraphEditor.cursor_position_x SpaceGraphEditor.cursor_position_y SpaceGraphEditor.dopesheet SpaceGraphEditor.has_ghost_curves SpaceGraphEditor.mode SpaceGraphEditor.pivot_point SpaceGraphEditor.show_cursor SpaceGraphEditor.show_extrapolation SpaceGraphEditor.show_handles SpaceGraphEditor.show_markers SpaceGraphEditor.show_region_channels SpaceGraphEditor.show_region_footer SpaceGraphEditor.show_region_hud SpaceGraphEditor.show_region_ui SpaceGraphEditor.show_seconds SpaceGraphEditor.show_sliders SpaceGraphEditor.use_auto_lock_translation_axis SpaceGraphEditor.use_auto_merge_keyframes SpaceGraphEditor.use_auto_normalization SpaceGraphEditor.use_normalization SpaceGraphEditor.use_only_selected_keyframe_handles SpaceGraphEditor.use_realtime_update SpaceGraphEditor.bl_rna_get_subclass() SpaceGraphEditor.bl_rna_get_subclass_py() SpaceGraphEditor.draw_handler_add() SpaceGraphEditor.draw_handler_remove() Inherited Properties Inherited Functions
user: Describe Speaker Objects from the Blender manual or Python API, including usage steps and snippets.

assistant: # Speaker Objects

Speaker objects are used to play sound within the 3D Viewport.
They allow for spatial audio playback, making them useful for animations and interactive scenes.
Once added, a speaker’s properties can be adjusted in the Properties editor.

[image reference removed]

Speaker object.
user: Explain Ramp Blend Items in complete detail according to the official Blender documentation.

assistant: # Ramp Blend Items

MIX:
:   Mix.

---

DARKEN:
:   Darken.

MULTIPLY:
:   Multiply.

BURN:
:   Color Burn.

---

LIGHTEN:
:   Lighten.

SCREEN:
:   Screen.

DODGE:
:   Color Dodge.

ADD:
:   Add.

---

OVERLAY:
:   Overlay.

SOFT_LIGHT:
:   Soft Light.

LINEAR_LIGHT:
:   Linear Light.

---

DIFFERENCE:
:   Difference.

EXCLUSION:
:   Exclusion.

SUBTRACT:
:   Subtract.

DIVIDE:
:   Divide.

---

HUE:
:   Hue.

SATURATION:
:   Saturation.

COLOR:
:   Color.

VALUE:
:   Value.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: For this example the model was shot against a *white* background.
Using the Luminance Key node, we get a matte out where the background is white,
and the model is black; the opposite of what we want.
If we wanted to use the matte, we have to switch the white and the black.
How to do this? Color Ramp node to the rescue – we set the left color to White Alpha 1.0,
and the right color to be Black Alpha 0.0. Thus, when the Color Ramp gets in black,
it spits out white, and vice versa. The reversed mask is shown;
its white outline is usable as an alpha mask now.

[image reference removed]

Using Luma Key with a twist.

Now to mix, we do not really need the *Alpha Over* node;
we can just use the mask as our Factor input. In this kinda weird case,
we can use the matte directly; we just switch the input nodes. As you can see,
since the matte is white (1.0) where we do not want to use the model picture,
we feed the background photo to the bottom socket
(recall the Mix node uses the top socket where the factor is 0.0,
and the bottom socket where the factor is 1.0). Feeding our original photo into the top socket
means it will be used where the Luminance Key node has spit out Black. Voilà,
our model is teleported from Atlanta to aboard a cruise ship docked in Miami.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_deform_mesh-deform_panel.png)

The Mesh Deform modifier.

Object
:   The name of the mesh object to be used as the deforming cage.

Vertex Group
:   An optional vertex group of the object’s mesh to restrict the vertices that
    will be affected by this modifier.
    Vertices not in this group will not be deformed.

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

        The setting reverses the weight values of the group.

Precision
:   Controls the accuracy with which the deform mesh cage alters the deformed object,
    when the points on the cage are moved.
    Raising this value higher can greatly increase the time it takes
    to complete the binding calculations,
    but it will get more accurate cage mapping to the deformed object.

    This setting becomes unavailable once a cage has been bound.

Dynamic
:   When activated, other mesh altering features (such as other modifiers and shape keys)
    are taken into account when binding, increasing deformation quality.

    The setting is deactivated by default to save memory and processing time when binding.
    Like with *Precision*, this setting is unavailable once a cage has been bound.

Bind
:   Links the current vertex positions of both the modified geometry and the deforming *Object* chosen together.
    An unbound *Mesh Deform* modifier has no effect,
    it must be bound so that altering the shape of the deform mesh cage
    actually alters the shape of the modified object.

Unbind
:   When a deformed object has been associated to a deform mesh cage,
    it can later be disassociated by clicking the *Unbind* button which replaced the *Bind* one.

    When *Unbind* is clicked, the *deforming mesh cage* will keep its current shape,
    it will not reset itself back to its initial shape.
    If you need this original shape, you will have to save a copy of it before you alter it.

    The deformed object will, however, reset back to its original shape that it had
    before it was bound to the deform mesh cage.
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.html).
The grid points are equally spaced between the *Min* and *Max* bounds of the grid.
user: Describe Vertex Group Categories from the Blender manual or Python API, including usage steps and snippets.

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.xhtml). 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: Explain Set User Region in complete detail according to the official Blender documentation.

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

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

assistant: # LineStyleGeometryModifier_TipRemover(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_TipRemover(*LineStyleGeometryModifier*)
:   Remove a piece of stroke at the beginning and the end of stroke backbone

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    tip_length
    :   Length of tips to be removed

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (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.LineStyleGeometryModifier_TipRemover.type "bpy.types.LineStyleGeometryModifier_TipRemover.type")
user: How do I use Drivers in Blender? Include parameters, examples, warnings and best practices.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On macOS, graphics drivers are built into the operating system and the only way to get newer drivers is to upgrade
macOS as a whole to the latest version.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Points
:   Number of points on each of the circles.

Inner Radius, Outer Radius
:   Radii of the two circles on which to place the control points.
    The inner radius can be larger than the outer radius.

Twist
:   Angle offset of the inner circle.
    The twist value rotates the points on the circle corresponding with the inner radius
    counterclockwise by the given angle.
user: How do I use Property Unit Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Property Unit Items

NONE:
:   None.

LENGTH:
:   Length.

AREA:
:   Area.

VOLUME:
:   Volume.

ROTATION:
:   Rotation.

TIME:
:   Time (Scene Relative).

TIME_ABSOLUTE:
:   Time (Absolute).

VELOCITY:
:   Velocity.

ACCELERATION:
:   Acceleration.

MASS:
:   Mass.

CAMERA:
:   Camera.

POWER:
:   Power.

TEMPERATURE:
:   Temperature.

WAVELENGTH:
:   Wavelength.

COLOR_TEMPERATURE:
:   Color Temperature.

FREQUENCY:
:   Frequency.
user: What is Special Characters and how is it used in Blender Python scripting?

assistant: This is a limited character map to insert characters which aren’t available from the keyboard.
Many other special characters can be “composed”, see [Accent Characters](#accent-characters).
If you need others, you will have to copy-paste them from an external editor or character map program.
user: Explain Damping in complete detail according to the official Blender documentation.

assistant: Tension
:   Amount of damping in stretching behavior.

Compression
:   Amount of damping in compression behavior.

Structural
:   Amount of damping in stretching behavior (only in linear bending model).

Shear
:   Amount of damping in shearing behavior.

Bending
:   Amount of damping in bending behavior.
user: How do I use More in Blender? Include parameters, examples, warnings and best practices.

assistant: Nodes for geometric data, texture coordinates,
layering shaders and non-physically-based tricks can be found in:

- [Vector Nodes](utilities/vector/index.html)
- [Color Nodes](color/index.html)
- [Utilities Nodes](utilities/index.html)
user: How do I use Volumetric Data in Blender? Include parameters, examples, warnings and best practices.

assistant: Format
:   File format for volume based simulation data (i.e. grids and particles).

    Uni Cache:
    :   Blender’s own caching format with some compression.
        Each simulation object is stored in its own `.uni` cache file.

    OpenVDB:
    :   Advanced and efficient storage format.
        All simulation objects (i.e. grids and particles) are stored in a single `.vdb` file per frame.

Compression OpenVDB Only
:   Compression method that is used when writing OpenVDB cache files.

    Zip:
    :   Cache files will be written with `Zip` compression. Effective but slower than `Blosc`.

    Blosc:
    :   Cache files will be written with `Blosc` compression. Multithreaded compression,
        similar in size and quality to `Zip` compression.

    None:
    :   Cache files will be written without any compression.

Precision OpenVDB Only
:   Precision level that is used when writing OpenVDB cache files.

    Full:
    :   Volumetric data (e.g. grids, particles) will be written with full precision (32-bit).

    Half:
    :   Volumetric data (e.g. grids, particles) will be written with half precision (16-bit).

    Mini:
    :   Volumetric data (e.g. grids, particles) will be written with mini float precision (8-bit) where possible.
        For cache data where this is not possible, 16-bit floats will be used instead.

Meshes Liquids Only
:   File format for the mesh cache files.

    Binary Object: Mesh data files with some compression.
    Object: Simple, standard data format for mesh data.

Export Mantaflow Script
:   Export the simulation as a standalone Mantaflow script when baking the scene (exported on “Bake Data”).
    Usually, only developers and advanced users who know how to use the Mantaflow GUI will
    make use of this functionality. Use a [Debug Value](../../../../advanced/operators.xhtml#bpy-ops-wm-debug-menu) of `3001` to enable.
user: Give a detailed overview of Vertex Buffers: syntax, arguments, return values, common patterns.

assistant: A *Vertex Buffer Object* (VBO) ([`gpu.types.GPUVertBuf`](gpu.types.html#gpu.types.GPUVertBuf "gpu.types.GPUVertBuf"))
is an array that contains the vertex attributes needed for drawing using a specific shader.
Typical vertex attributes are *location*, *normal*, *color*, and *uv*.
Every vertex buffer has a *Vertex Format* ([`gpu.types.GPUVertFormat`](gpu.types.html#gpu.types.GPUVertFormat "gpu.types.GPUVertFormat"))
and a length corresponding to the number of vertices in the buffer.
A vertex format describes the attributes stored per vertex and their types.

The following code demonstrates the creation of a vertex buffer that contains 6 vertices.
For each vertex 2 attributes will be stored: The position and the normal.

```
import gpu
vertex_positions = [(0, 0, 0), ...]
vertex_normals = [(0, 0, 1), ...]

fmt = gpu.types.GPUVertFormat()
fmt.attr_add(id="pos", comp_type='F32', len=3, fetch_mode='FLOAT')
fmt.attr_add(id="normal", comp_type='F32', len=3, fetch_mode='FLOAT')

vbo = gpu.types.GPUVertBuf(len=6, format=fmt)
vbo.attr_fill(id="pos", data=vertex_positions)
vbo.attr_fill(id="normal", data=vertex_normals)
```

This vertex buffer could be used to draw 6 points, 3 separate lines, 5 consecutive lines, 2 separate triangles, …
E.g. in the case of lines, each two consecutive vertices define a line.
The type that will actually be drawn is determined when the batch is created later.
user: Describe Select Pattern from the Blender manual or Python API, including usage steps and snippets.

assistant: Selects all bones whose name matches a given pattern.
Supported wild-cards: \* matches everything, ? matches any single character,
[abc] matches characters in “abc”, and [!abc] match any character not in “abc”.
As an example \*house\* matches any name that contains “house”,
while floor\* matches any name starting with “floor”.

Case Sensitive
:   The matching can be chosen to be case sensitive or not.

Extend
:   When *Extend* checkbox is checked the selection is extended instead of generating a new one.