PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for NodeSeparateBundle(NodeInternal), preserving all code examples.

assistant: # NodeSeparateBundle(NodeInternal)

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

*class* bpy.types.NodeSeparateBundle(*NodeInternal*)
:   Split a bundle into multiple sockets.

    active_index
    :   Index of the active item

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

    bundle_items
    :   Type:
        :   [`NodeSeparateBundleItems`](bpy.types.NodeSeparateBundleItems.html#bpy.types.NodeSeparateBundleItems "bpy.types.NodeSeparateBundleItems") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`NodeSeparateBundleItem`](bpy.types.NodeSeparateBundleItem.html#bpy.types.NodeSeparateBundleItem "bpy.types.NodeSeparateBundleItem"), (readonly)

    define_signature
    :   This node defines a bundle signature that should be used by other nodes

        Type:
        :   boolean, default False

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for LaplacianDeformModifier(Modifier), preserving all code examples.

assistant: # LaplacianDeformModifier(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.LaplacianDeformModifier(*Modifier*)
:   Mesh deform modifier

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    is_bind
    :   Whether geometry has been bound to anchors

        Type:
        :   boolean, default False, (readonly)

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

    vertex_group
    :   Name of Vertex Group which determines Anchors

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: In the Node Editor the inputs can be renamed, shuffled and removed.
This is also the place where sub-steps can be defined for a simulation.

### Inputs

Geometry
:   Standard geometry input, which is available by default to input geometry into the simulation zone.
    More bake items can be added by dragging sockets into the blank socket or in the *Simulation State* panel.
    Items can be renamed by `Ctrl`-`LMB` on the socket name or in the nodes *Properties* panel.

Delta Time
:   The time in seconds between frames.
    Essentially this the inverse of the render [Frame Rate](../../../render/output/properties/format.html#bpy-types-rendersettings-fps).

    This delta is used to drive the simulation by connecting it node setups that depend on a rate.
    This will keep the simulation playback consistent when the frame rate changes.

Skip
:   Forward the output of the simulation input node directly
    to the output node and ignore the nodes in the simulation zone.
user: Explain HSV Example in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/compositing_types_color_hue-saturation_example.jpg)

A basic example.

[[image reference removed]](../../../_images/compositing_types_input_mask_example.png)

An example of using the Factor input for masking.
user: Show practical ways to work with Making Single User in a Blender add-on or script – include code.

assistant: When a data-block is shared between several users, you can make a copy of it for a given user.
To do so, click on the user count button to the right of its name.
This will duplicate that data-block and assign the newly created copy to that usage only.
user: Provide the full official documentation entry for Action Strips, preserving all code examples.

assistant: An action strip plays the keyframes inside an [action](../../animation/actions.html).
You can create one using Add ‣ Action. Another way is to click
[Push Down Action](tracks.html#bpy-ops-nla-action-pushdown) in the NLA’s Action Track –
this will create a strip based on the object’s active action.

Multiple strips can reference the same action, so that you can potentially change
multiple parts of the animation by editing a single set of keyframes.

A strip can be shorter than its underlying action, be it through cropping,
speeding up, or both. It can also be longer than its underlying action,
be it through extending, slowing down, or both. See the
[Sidebar](sidebar.html#nla-sidebar-action-clip) for details.
user: How do I use face.skin_eye in Blender? Include parameters, examples, warnings and best practices.

assistant: Implements a skin system [parent controller](skin.xhtml#rigify-rigs-skin-skin-parents) that manages
two skin chains for the top and bottom eyelids in addition to generating the eye rotation mechanism.

The rig must have two child skin chains with names tagged with `.T` and `.B` symmetry
to mark the top and bottom eyelid, which are connected at their ends forming eye corners.
The chains are rigged to follow the surface of the eye and twist to its normal.

In addition, it creates target controls for aiming the eye, including a master control shared by
all eyes under the same parent rig. The eyelids are rigged to follow the movement of the eyeball
with adjustable influence.

Eyeball and Iris Deforms
:   Generates deform bones for the eyeball and the iris, the latter copying XZ scale from
    the eye target control. The iris is located at the tail of the ORG bone.

Eyelid Detach Option
:   Generates a slider to disable the mechanism that keeps eyelid controls stuck to the surface of the eye.

Split Eyelid Follow Slider
:   Generates two separate sliders for controlling the influence of the eye rotation on X and Z eyelid motion.

Eyelids Follow Default
:   Depending on *Split Eyelid Follow Slider*, specifies the default values for the split follow sliders,
    or fixed factors to be multiplied with the single common follow influence slider value.
user: Provide the full official documentation entry for Shading, preserving all code examples.

assistant: ### Principled Volume

[Principled Volume](../../shader_nodes/shader/volume_principled.xhtml)
is a physically-based volume shader that can be used to create a wide range of volume materials.
It supports scattering, absorption and emission in one easy to use node.
Fire can be rendered with blackbody emission.

[image reference removed]

Smoke and fire rendered with Principled Volume shader.

### Volume Components

For more control, volume shading components can be manually combined into a custom shader setup.

- [Volume Absorption](../../shader_nodes/shader/volume_absorption.xhtml)
  will absorb part of the light as it passes through the volume.
  This can be used to shade for example black smoke or colored glass objects, or mixed with the Volume Scatter node.
  This node is similar to the transparent BSDF node,
  it blocks part of the light and lets other light pass straight through.
- [Volume Scatter](../../shader_nodes/shader/volume_scatter.xhtml)
  lets light scatter in other directions as it hits particles in the volume.
  The anisotropy defines in which direction the light is more likely to scatter.
  A value of 0 will let light scatter evenly in all directions (similar to the diffuse BSDF node),
  negative values let light scatter mostly backwards, and positive values let light scatter mostly forward.
  This can be used to shade white smoke or clouds for example.
- [Emission](../../shader_nodes/shader/emission.xhtml)
  will emit light from the volume, for example for fire.

[image reference removed]

Volume Absorption, Scatter and Emission

### Attributes

When rendering smoke and fire, volume attributes are used to define the shape and shading of the volume.
The Principled Volume shader will use them by default, while custom volume shaders can use
the Attribute node to get attributes such as density, color and temperature.

### Density

All volume shaders have a density input.
The density defines how much of the light will interact with the volume,
getting absorbed or scattered, and how much will pass straight through. For effects such as
smoke you would specify a density field to indicate where in the volume there is smoke and
how much (density bigger than 0), and where there is no smoke (density equals 0).

Volumes in the real world consist of particles,
a higher density means there are more particles per unit volume. More particles means there is
a higher chance for light to collide with a particle and get absorbed or scattered,
rather than passing straight through.
user: Provide the full official documentation entry for Cache, preserving all code examples.

assistant: # Cache

In order to improve real-time response and avoid unnecessary recalculation of particles,
the particle data can be cached in memory or stored on a drive.

The *Emitter* particle system uses a unified system for caching and baking (together with Soft Body and Cloth).

[image reference removed]

Particles Cache settings.
user: How do I use Limitations/Considerations in Blender? Include parameters, examples, warnings and best practices.

assistant: The positioning of the instanced geometry relative to the face is dependent upon the position
of the child objects relative to the instancer’s origin. This can lead to some visual artifacts
in the 3D Viewport as the geometry of the original objects overlaps or intersects with
the instanced geometry.
One workaround is to move the origin of the instancer mesh off of the plane of the faces.

If the geometry of the children is not symmetrical then the orientation of the face
(as determined by the order of its vertices) could matter. As of 2.70 Blender does not have
tools which allow you to adjust the ordering of the vertices on a face.

However, there is a workflow that lets you control for this. Make a single square and
enable the *Instancing Faces* so you can see the instanced geometry in the 3D Viewport.
If the orientation is not what you want, rotate the face until it is how you want.
Typically you want to do the rotation in Edit Mode, not Object Mode,
but this is not a hard rule.

Once you have the orientation correct,
Duplicate the face and move the duplicate where you want it.
Repeat this process until you have enough faces.
Since it is common for these faces to butt up against one another,
your geometry will have lots of duplicate vertices.
Use the *Merge by Distance* button in the Tools panel.

Demo Video

[A short video illustrating this workflow](https://www.youtube.com/watch?v=diI8xJ9oo_8)
user: How do I use Platform Specific in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Windows

#### Mixed Python Libraries (DLLs)

If Python is raising errors or you have an add-on that just fails when enabled with an error – e.g: `... is not a
valid Win32 application.` – this may be caused by some inconsistency in the Python libraries. While Blender comes
with its own bundled Python interpreter, duplicate, incompatible libraries can cause problems.

[image reference removed]

A Python traceback.

To find out which Python Library caused the Problem check the error message.

This is normally reported somewhere around the bottom line of the traceback. With the error above you see the problem
is caused while trying to import `_socket`. This corresponds to either a file named `_socket.py` or
`_socket.pyd`.

To help troubleshoot this problem, the following script can be pasted into the Text editor and run to check for
duplicate libraries in your search path.
(The output will show in [Command Line Window](../advanced/command_line/index.html).)

```
import os
import sys

# Change this based on the library you wish to test
test_lib = "_socket.pyd"

def GetSystemDirectory():
    from ctypes import windll, create_string_buffer, sizeof
    GetSystemDirectory = windll.kernel32.GetSystemDirectoryA
    buffer = create_string_buffer(260)
    GetSystemDirectory(buffer, sizeof(buffer))
    return os.fsdecode(buffer.value)

def library_search_paths():
    return (
        # Windows search paths
        os.path.dirname(sys.argv[0]),
        os.getcwd(),
        GetSystemDirectory(),
        os.environ["WINDIR"],  # GetWindowsDirectory
        *os.environ["PATH"].split(";"),

        # regular Python search paths
        *sys.path,
        )

def check_library_duplicate(libname):
    paths = [p for p in library_search_paths()
             if os.path.exists(os.path.join(p, libname))]

    print("Library %r found in %d locations:" % (libname, len(paths)))
    for p in paths:
        print("- %r" % p)

check_library_duplicate(test_lib)
```
user: Show practical ways to work with SDF Grid Laplacian Node in a Blender add-on or script – include code.

assistant: # SDF Grid Laplacian Node

[image reference removed]

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

Laplacian flow is a computationally efficient alternative to
[mean curvature flow](sdf_grid_mean_curvature.xhtml)
smoothing. It is particularly useful for refining SDFs generated from
meshes or boolean operations, where sharp transitions or voxel artifacts may occur.
The operation helps improve the quality of surfaces before converting the SDF back into a mesh.
user: How do I use ScrewModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ScrewModifier(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.ScrewModifier(*Modifier*)
:   Revolve edges

    angle
    :   Angle of revolution

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

    axis
    :   Screw axis

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

    iterations
    :   Number of times to apply the screw operation

        Type:
        :   int in [1, 10000], default 1

    merge_threshold
    :   Limit below which to merge vertices

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

    object
    :   Object to define the screw axis

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

    render_steps
    :   Number of steps in the revolution

        Type:
        :   int in [1, 10000], default 16

    screw_offset
    :   Offset the revolution along its axis

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

    steps
    :   Number of steps in the revolution

        Type:
        :   int in [1, 10000], default 16

    use_merge_vertices
    :   Merge adjacent vertices (screw offset must be zero)

        Type:
        :   boolean, default False

    use_normal_calculate
    :   Calculate the order of edges (needed for meshes, but not curves)

        Type:
        :   boolean, default False

    use_normal_flip
    :   Flip normals of lathed faces

        Type:
        :   boolean, default False

    use_object_screw_offset
    :   Use the distance between the objects to make a screw

        Type:
        :   boolean, default False

    use_smooth_shade
    :   Output faces with smooth shading rather than flat shaded

        Type:
        :   boolean, default True

    use_stretch_u
    :   Stretch the U coordinates between 0 and 1 when UVs are present

        Type:
        :   boolean, default False

    use_stretch_v
    :   Stretch the V coordinates between 0 and 1 when UVs are present

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Film, preserving all code examples.

assistant: # Film

Filter Size
:   Due to limited resolution of images and computer screens, pixel filters are needed to avoid [Aliasing](../../../glossary/index.html#term-Aliasing).
    This is achieved by slightly blurring the image to soften edges.

    This Setting controls how much the image is softened;
    lower values give more crisp renders, higher values are softer and reduce aliasing.

Transparent
:   Render the background transparent, for compositing the image over another background after rendering.

Overscan
:   Percentage of the render size to add to the internal render buffer.
    This will have a serious impact on performance but can fix
    render glitches around the perimeter of the rendered image.
user: Give a detailed overview of Node Operators: syntax, arguments, return values, common patterns.

assistant: rs

bpy.ops.node.toggle_viewer()
:   Toggle selected viewer node in compositor and geometry nodes

bpy.ops.node.translate_attach(*\**, *TRANSFORM_OT_translate=None*, *NODE_OT_attach=None*)
:   Move nodes and attach to frame

    Parameters:
    :   - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items
        - **NODE_OT_attach** (`NODE_OT_attach`, (optional)) – Attach Nodes, Attach active node to a frame

bpy.ops.node.translate_attach_remove_on_cancel(*\**, *TRANSFORM_OT_translate=None*, *NODE_OT_attach=None*)
:   Move nodes and attach to frame

    Parameters:
    :   - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items
        - **NODE_OT_attach** (`NODE_OT_attach`, (optional)) – Attach Nodes, Attach active node to a frame

bpy.ops.node.tree_path_parent(*\**, *parent_tree_index=0*)
:   Go to parent node tree

    Parameters:
    :   **parent_tree_index** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Parent Index, Parent index in context path

    File:
    :   [startup/bl_operators/node.py:892](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/node.py#L892)

bpy.ops.node.view_all()
:   Resize view so you can see all nodes

bpy.ops.node.view_selected()
:   Resize view so you can see selected nodes

bpy.ops.node.viewer_border(*\**, *xmin=0*, *xmax=0*, *ymin=0*, *ymax=0*, *wait_for_input=True*)
:   Set the boundaries for viewer operations

    Parameters:
    :   - **xmin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Min
        - **xmax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Max
        - **ymin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Min
        - **ymax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Max
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input

bpy.ops.node.viewer_shortcut_get(*\**, *viewer_index=0*)
:   Toggle a specific viewer node using 1,2,..,9 keys

    Parameters:
    :   **viewer_index** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Viewer Index, Index corresponding to the shortcut, e.g. number key 1 corresponds to index 1 etc..

    File:
    :   [startup/bl_operators/node.py:1280](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/node.py#L1280)

bpy.ops.node.viewer_shortcut_set(*\**, *viewer_index=0*)
:   Create a viewer shortcut for the selected node by pressing ctrl+1,2,..9

    Parameters:
    :   **viewer_index** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Viewer Index, Index corresponding to the shortcut, e.g. number key 1 corresponds to index 1 etc..

    File:
    :   [startup/bl_operators/node.py:1220](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/node.py#L1220)
user: Describe Area Options from the Blender manual or Python API, including usage steps and snippets.

assistant: `RMB` on the border opens the *Area Options*.

Vertical/Horizontal Split
:   Shows an indicator line that lets you select the area and position where to split.
    `Tab` switches between vertical/horizontal.

Join Up/Down/Left/Right
:   Shows the join direction overlay.

Swap Areas
:   Swaps this area with the adjacent one.
user: How do I use Save & Load in Blender? Include parameters, examples, warnings and best practices.

assistant: If you trust the source of your blend-files, you can enable *Auto Run Python Scripts*. This option is meant to protect
you from malicious Python scripts in blend-files that you got from someone else. Many users turn this option on, as
advanced rigs tend to use scripts of some sort. **Use caution, as this is a global setting, and may allow potentially
malicious Python code from an untrusted source to run.**

See Save & Load [Auto Run Python Scripts](../../editors/preferences/save_load.xhtml#bpy-types-preferencesfilepaths-use-scripts-auto-execute) Preference.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

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

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

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

[image reference removed]

An armature in Pose Mode, B-Bone visualization: Bone.003 has one segment,
Bone.004 has four, and Bone.005 has sixteen.
user: How do I use Attribute Conversion Operator in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

This operator found in the *Attributes* panel of the property editor can change the
domain or data type of an attribute.

Due to ongoing development in the area of attributes, many areas of Blender can not yet work with
the generic (identified with a name, stored on any domain with any data type) attributes used by
geometry nodes. That makes this operator an essential workaround in some cases where existing
tools must be used with data generated from geometry nodes.

Mode
:   Generic:
    :   Interpolate and convert the attribute between the domains and data types described on this page.

    Vertex Group:
    :   Create a [Vertex Group](../meshes/properties/vertex_groups/index.xhtml)
        from the attribute, which corresponds to a float attribute on the point domain.
user: Give a detailed overview of NDOF: syntax, arguments, return values, common patterns.

assistant: These preferences control how an [NDOF device](../../getting_started/configuration/hardware.html#hardware-ndof) (3D mouse) interacts with the 3D Viewport.
These settings allow customization of navigation, orbit behavior, and motion sensitivity.
They can also be accessed using the `NDOFMenu` button on supported devices,
which opens a pop-up menu to adjust them directly in the viewport.

Navigation Mode
:   Sets how the 3D mouse navigates in the 3D Viewport.

    Object:
    :   Feels like holding the object in your hand. Moving the 3D mouse moves the object in that direction.

    Fly/Helicopter:
    :   Moves the camera through the scene, like flying or piloting a helicopter.
        For example, pushing the 3D mouse up moves the camera up.

Lock Horizon
:   Keeps the view level by preventing horizon tilt during navigation.

Orbit Center – Auto
:   Automatically determines the rotation center. If the full model is visible,
    its center of volume is used. When zoomed in, the rotation center shifts to the nearest visible object.

Orbit Center – Selected Items
:   Limits the orbit center to the center of the currently selected objects.

Show – Orbit Axis
:   Displays an axis overlay to indicate the current orbit rotation direction.

Show – Orbit Center
:   Displays a marker showing the current orbit center point.

### Advanced

Pan Sensitivity
:   Controls how quickly the view pans in response to NDOF input.

Orbit Sensitivity
:   Controls how quickly the view orbits in response to NDOF input.

Deadzone
:   Sets the minimum threshold for motion detection. Helps avoid unintended movement from slight touches.

Zoom Direction
:   Determines which direction on the 3D mouse triggers zooming.

    Forward/Backward:
    :   Zooms in or out by pushing or pulling the 3D mouse forward/backward.

    Up/Down:
    :   Zooms in or out by pushing or pulling the 3D mouse upward/downward.

Invert Pan
:   Inverts panning on the selected X, Y, or Z axis.

Invert Rotate
:   Inverts rotation direction on the selected X, Y, or Z axis.

Pan / Zoom Camera View
:   When in camera view, pans or zooms the camera instead of exiting the view during orbiting.
user: Describe Multiple Materials from the Blender manual or Python API, including usage steps and snippets.

assistant: Normally, different colors or patterns on an object are achieved by adding textures to your materials.
However, in some applications you can obtain multiple colors on an object by assigning
different materials to the individual faces of the object.

To apply several materials to different faces of the same object,
you use the Material Slots options in the Materials header panel.

The workflow for applying a second material to some faces of an object covered by
a base material is as follows:

1. In Object Mode, create a base material.
2. Go into Edit Mode and Face Select (a new list will appear below
   the Active Material list with *Assign*, *Select*, *Deselect* buttons).
3. Select the faces to be colored with the second material.
4. In the Object Material Slots list, [create a new slot](#bpy-ops-material-new) or select an existing material.
5. Click the *Assign* button, and the material will appear on the selected object faces.
user: What is Classification and how is it used in Blender Python scripting?

assistant: Bones can be classified into two types depending on their
[Deform](properties/deform.xhtml) setting:

### Deforming Bones

Bones that have the *Deform* setting enabled will drag vertices along with them.
For example, you could have a bone in a character’s upper arm and another in
the lower arm, and then rotate and flex the arm by transforming these bones.

### Control Bones

Bones that have the *Deform* setting disabled do not drag any vertices along.
Instead, they’re typically used to control other bones.

A common use case is
[inverse kinematics](../posing/bone_constraints/inverse_kinematics/introduction.xhtml):
rotating the above two arm bones manually is a bit of a pain, so instead,
you can add a control bone and configure the arm bones to automatically orient
themselves towards it. This way, you can simply position the control bone
where the character’s hand should be, which is much easier.
user: How do I use Interpolate in Blender? Include parameters, examples, warnings and best practices.

assistant: When you are animating simple shapes you can use the interpolate tool
to automatically add new breakdown keyframes.

See [Interpolate tool](../modes/draw/tools/interpolate.xhtml#tool-grease-pencil-draw-interpolate) for more details.
user: Explain Faces in complete detail according to the official Blender documentation.

assistant: Faces are used to build the actual surface of the object.
They are what you see when you render the mesh.
If this area does not contain a face,
it will simply be transparent or nonexistent in the rendered image.

A face is defined as the area between either three (triangles), four (quadrangles) or more (n-gons) vertices,
with an edge on every side. The faces are often abbreviated to *tris, quads & n-gons*.

Triangles are always flat and therefore easy to calculate. On the other hand,
quadrangles “deform well” and are therefore preferred for animation and subdivision modeling.
user: Describe Meshes from the Blender manual or Python API, including usage steps and snippets.

assistant: glTF’s internal structure mimics the memory buffers commonly used by graphics chips
when rendering in real-time, such that assets can be delivered to desktop, web, or mobile clients
and be promptly displayed with minimal processing. As a result, quads and n-gons
are automatically converted to triangles when exporting to glTF.
Discontinuous UVs and flat-shaded edges may result in moderately higher vertex counts in glTF
compared to Blender, as such vertices are separated for export.
Likewise, curves and other non-mesh data are not preserved,
and must be converted to meshes prior to export.

### GPU Instances

When the option is enable in Exporter, instances are exported using the `EXT_mesh_gpu_instancing` extension.
There are some limitations, at export:

- Instances must be meshes, and don’t have any children themselves
- Instances must all be children of the same object.
- This extension doesn’t manage material variation. That means that the generated file may include all instances with
  same materials.
- Instances detected are objects sharing the same mesh data.

At import, instances are created by creating objects sharing the same mesh data.
user: Give a detailed overview of Setting up Materials: syntax, arguments, return values, common patterns.

assistant: Materials can be created in either the [Material properties](../../editors/properties_editor.xhtml),
or in the [Shader Editor](../../editors/shader_editor.xhtml).
These provide a different view of the same shader nodes and material settings.

The default Shading workspace has a Shader Editor and a 3D Viewport that can be set to
Material Preview or Rendered shading, to interactively preview how the material interacts
with objects and lights in the scene.

Materials are data-blocks that can be [assigned](assignment.xhtml)
to one or more objects, and different materials can be assigned to different parts of meshes.

Image textures can be created from scratch in [Texture Paint Mode](../../sculpt_paint/texture_paint/index.xhtml),
or by loading in existing images with the [Image Texture node](../shader_nodes/textures/image.xhtml).
A variety of [procedural texture nodes](../shader_nodes/textures/index.xhtml) is also available.
user: Provide the full official documentation entry for Brush Gpencil Sculpt Types Items, preserving all code examples.

assistant: # Brush Gpencil Sculpt Types Items

SMOOTH:
:   Smooth.

    Smooth stroke points.

THICKNESS:
:   Thickness.

    Adjust thickness of strokes.

STRENGTH:
:   Strength.

    Adjust color strength of strokes.

RANDOMIZE:
:   Randomize.

    Introduce jitter/randomness into strokes.

GRAB:
:   Grab.

    Translate the set of points initially within the brush circle.

PUSH:
:   Push.

    Move points out of the way, as if combing them.

TWIST:
:   Twist.

    Rotate points around the midpoint of the brush.

PINCH:
:   Pinch.

    Pull points towards the midpoint of the brush.

CLONE:
:   Clone.

    Paste copies of the strokes stored on the internal clipboard.
user: Describe Details from the Blender manual or Python API, including usage steps and snippets.

assistant: When Blender is started on a Microsoft Windows operating system, the *Console Window*
(called the Command Prompt) is first created as a separate window on the desktop.
The main Blender window will also appear and the *Console Window* will then be toggled off.
To display the console again, go to Window ‣ Toggle System Console.

To start Blender from the command line you need to open an instance of Command Prompt.
To do this, type `OSKey`-`R` then type `cmd`; this will open the Command Prompt window.
You then need to find the path to the Blender executable. If you installed Blender via the installer
then it can be found here:

```
C:\Program Files\Blender Foundation\Blender\blender.exe
```

[image reference removed]

Blender’s Console Window on Microsoft Windows.

The screenshot shows the Blender *Console Window* on Microsoft Windows directly after starting
Blender and then a short while later after opening a file along with the relevant messages.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Grid
:   The input grid that defines the volume within which points are distributed.
    The grid’s values determine where points can be placed—typically based on
    density or occupancy.

Density Random
:   A scaling factor applied to the voxel values that determines the expected
    number of points to generate per unit volume.
    Higher values produce denser distributions of points.

Seed Random
:   The seed value used by the random number generator for reproducible results.
    Changing this value alters the random point distribution without affecting
    other parameters.

Spacing Grid
:   The distance between points when using the *Grid* distribution method.
    Controls how tightly points are packed inside the volume.

Threshold Grid
:   The minimum voxel density value required for a point to be generated.
    Voxels below this threshold are ignored, which can be used to restrict
    point placement to denser or more meaningful regions.
user: Provide the full official documentation entry for The Beginning, preserving all code examples.

assistant: Blender was created by Ton Roosendaal, a Dutch art director and self-taught software developer. Attracted to all
things technical and creative, Roosendaal began a degree in Industrial Design, but dropped out in order to start his
own 3D animation studio, NeoGeo, in 1989 (the video game console of the same name appeared a year later). Initially
based in Roosendaal’s attic, NeoGeo grew rapidly, garnering awards and becoming the biggest company of its type in the
Netherlands.

Roosendaal wrote the first source files titled “Blender” on the 2nd of January, 1994, still considered Blender’s
official birthday. Originally, Blender was planned as an in-house application for NeoGeo; it grew from a series of
pre-existing tools, including a ray-tracer built for the Amiga. This early version of Blender was intended to address
a perennial frustration among creatives: when a difficult client requires multiple changes to a project, how do you
implement those changes painlessly? Thanks to its highly configurable approach, Blender aimed at providing an answer.
(As an aside: the name refers to a song by a Swiss electronic band, Yello).

Roosendaal invested his savings in a Silicon Graphics workstation. Costing the equivalent of thirty thousand US
dollars, this computer led to Blender 1.0. Launched in January 1995, this first iteration of Blender proper
incorporated then innovative ideas, including a single window which could be subdivided as the user saw fit.

At the time, 3D was considered commercially uninteresting. However, Roosendaal had fallen in love with what he
describes as its “magical ability to create a whole world in a computer.” So when NeoGeo closed, he and partner Frank
van Beek founded a new company focused on further developing and marketing Blender. Not a Number (NaN) opened its
doors in June 1998, distributing Blender under a freemium pricing strategy: the software was free to download, with
NaN selling keys to unlock more advanced features.
user: What is Playback Controls and how is it used in Blender Python scripting?

assistant: The Playback Controls region contains controls and options
related to playback, keying, auto keyframing, and transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: View Vector
:   A normalized vector, in camera space, from the camera to the shading point.

View Z Depth
:   The distance each pixel is away from the camera.

View Distance
:   Distance from the camera to the shading point.
user: Provide the full official documentation entry for Poll Function, preserving all code examples.

assistant: y.types.NodesModifier.html#bpy.types.NodesModifier.node_group "bpy.types.NodesModifier.node_group") - [`Scene.compositing_node_group`](bpy.types.Scene.html#bpy.types.Scene.compositing_node_group "bpy.types.Scene.compositing_node_group") - [`SequencerCompositorModifierData.node_group`](bpy.types.SequencerCompositorModifierData.html#bpy.types.SequencerCompositorModifierData.node_group "bpy.types.SequencerCompositorModifierData.node_group") - [`ShaderNodeCustomGroup.node_tree`](bpy.types.ShaderNodeCustomGroup.html#bpy.types.ShaderNodeCustomGroup.node_tree "bpy.types.ShaderNodeCustomGroup.node_tree") - [`ShaderNodeGroup.node_tree`](bpy.types.ShaderNodeGroup.html#bpy.types.ShaderNodeGroup.node_tree "bpy.types.ShaderNodeGroup.node_tree") - [`SpaceNodeEditor.edit_tree`](bpy.types.SpaceNodeEditor.html#bpy.types.SpaceNodeEditor.edit_tree "bpy.types.SpaceNodeEditor.edit_tree") - [`SpaceNodeEditor.node_tree`](bpy.types.SpaceNodeEditor.html#bpy.types.SpaceNodeEditor.node_tree "bpy.types.SpaceNodeEditor.node_tree") - [`SpaceNodeEditor.selected_node_group`](bpy.types.SpaceNodeEditor.html#bpy.types.SpaceNodeEditor.selected_node_group "bpy.types.SpaceNodeEditor.selected_node_group") - [`SpaceNodeEditorPath.append`](bpy.types.SpaceNodeEditorPath.html#bpy.types.SpaceNodeEditorPath.append "bpy.types.SpaceNodeEditorPath.append") - [`SpaceNodeEditorPath.start`](bpy.types.SpaceNodeEditorPath.html#bpy.types.SpaceNodeEditorPath.start "bpy.types.SpaceNodeEditorPath.start") - [`Texture.node_tree`](bpy.types.Texture.html#bpy.types.Texture.node_tree "bpy.types.Texture.node_tree") - [`TextureNodeGroup.node_tree`](bpy.types.TextureNodeGroup.html#bpy.types.TextureNodeGroup.node_tree "bpy.types.TextureNodeGroup.node_tree") - [`UILayout.template_node_link`](bpy.types.UILayout.html#bpy.types.UILayout.template_node_link "bpy.types.UILayout.template_node_link") - [`UILayout.template_node_view`](bpy.types.UILayout.html#bpy.types.UILayout.template_node_view "bpy.types.UILayout.template_node_view") - [`World.node_tree`](bpy.types.World.html#bpy.types.World.node_tree "bpy.types.World.node_tree") |
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Top: Suzanne without modifiers. Middle: Suzanne with each type of Cast Modifier (Sphere, Cylinder and Cuboid).
Bottom: Same as above, but now only X axis is enabled.
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:263-Cast-Modifier.blend).
user: Provide the full official documentation entry for AdjustmentStrip(EffectStrip), preserving all code examples.

assistant: # AdjustmentStrip(EffectStrip)

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

*class* bpy.types.AdjustmentStrip(*EffectStrip*)
:   Sequence strip to perform filter adjustments to layers below

    animation_offset_end
    :   Animation end offset (trim end)

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

    animation_offset_start
    :   Animation start offset (trim start)

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

    input_count
    :   Type:
        :   int in [0, inf], default 0, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: These preferences control how an [NDOF device](../../getting_started/configuration/hardware.xhtml#hardware-ndof) (3D mouse) interacts with the 3D Viewport.
These settings allow customization of navigation, orbit behavior, and motion sensitivity.
They can also be accessed using the `NDOFMenu` button on supported devices,
which opens a pop-up menu to adjust them directly in the viewport.

Navigation Mode
:   Sets how the 3D mouse navigates in the 3D Viewport.

    Object:
    :   Feels like holding the object in your hand. Moving the 3D mouse moves the object in that direction.

    Fly/Helicopter:
    :   Moves the camera through the scene, like flying or piloting a helicopter.
        For example, pushing the 3D mouse up moves the camera up.

Lock Horizon
:   Keeps the view level by preventing horizon tilt during navigation.

Orbit Center – Auto
:   Automatically determines the rotation center. If the full model is visible,
    its center of volume is used. When zoomed in, the rotation center shifts to the nearest visible object.

Orbit Center – Selected Items
:   Limits the orbit center to the center of the currently selected objects.

Show – Orbit Axis
:   Displays an axis overlay to indicate the current orbit rotation direction.

Show – Orbit Center
:   Displays a marker showing the current orbit center point.

### Advanced

Pan Sensitivity
:   Controls how quickly the view pans in response to NDOF input.

Orbit Sensitivity
:   Controls how quickly the view orbits in response to NDOF input.

Deadzone
:   Sets the minimum threshold for motion detection. Helps avoid unintended movement from slight touches.

Zoom Direction
:   Determines which direction on the 3D mouse triggers zooming.

    Forward/Backward:
    :   Zooms in or out by pushing or pulling the 3D mouse forward/backward.

    Up/Down:
    :   Zooms in or out by pushing or pulling the 3D mouse upward/downward.

Invert Pan
:   Inverts panning on the selected X, Y, or Z axis.

Invert Rotate
:   Inverts rotation direction on the selected X, Y, or Z axis.

Pan / Zoom Camera View
:   When in camera view, pans or zooms the camera instead of exiting the view during orbiting.
user: What is Source and how is it used in Blender Python scripting?

assistant: The Source panel shows (and lets you change) the file which the strip points to,
as well as how this file should be displayed.

Directory
:   The folder containing the source file for the strip.

Filename
:   The name of the source file.
    Note that file names are limited to 256 characters.

Color Space
:   The color space of the source file.

    The list of color spaces depends on the active [OCIO config](../../../../render/color_management/opencolorio.xhtml#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../../../render/color_management/color_spaces.xhtml#ocio-config-default-color-spaces)

Alpha Mode
:   If the source file has an Alpha (transparency) channel, you can choose between
    [Straight Alpha](../../../../glossary/index.xhtml#term-Straight-Alpha) and [Premultiplied Alpha](../../../../glossary/index.xhtml#term-Premultiplied-Alpha).

Stream Index Movie Strip
:   The video stream to use, in case there are multiple.

Deinterlace
:   Applies deinterlacing to analog video.

Source Information
:   Displays information about the strip’s media.

    Resolution
    :   Resolution of the active strip’s image output.

    FPS Movie Strip
    :   The frame rate encoded into the video file.
        If this value does not match the scene’s [Frame Rate](../../../../render/output/properties/format.xhtml#bpy-types-rendersettings-fps),
        the perceived speed of the media will be wrong unless the speed is
        [changed](../../../../video_editing/edit/montage/strips/effects/speed_control.xhtml#video-editing-change-fps) to account for the difference.

### Options for Image Strips

Directory
:   The directory that contains the source file(s).

Filename
:   The name of the source file. For image sequences, this will be different for each frame.

Change Data/Files
:   Opens a File Browser to let you select a new set of images (as an alternative to modifying
    the above textboxes). Same as Strip ‣ Inputs ‣ Change Paths/Files.

### Options for Sound Strips

Sound
:   [Data-block menu](../../../../interface/controls/templates/data_block.xhtml#ui-data-block) to select a sound.

File Path
:   Path to the file used by the selected sound [data-block](../../../../interface/controls/templates/data_block.xhtml#ui-data-block).

Pack
:   [Pack](../../../../files/blend/packed_data.xhtml) the sound into the blend-file.

Caching
:   Sound file is decoded and loaded into the RAM.

Source Information
:   Displays information about the strip’s media.

    Sample Rate
    :   The number of samples per second the audio is encoded at.

    Channels
    :   The number of audio channels encoded into the audio stream.