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

assistant: [image reference removed]

The header of the Properties editor.

Display Filter `Ctrl`-`F`
:   Use this to search for properties by name. Matching properties remain visible; others are grayed out.
    The editor also highlights the first match and switches to the relevant tab automatically.

    Start a search with `Ctrl`-`F`, and clear it with `Alt`-`F`.

Data Context Path
:   Displays the name and icon of the current data-block (e.g. Object, Material, Scene), along with its hierarchical
    path within the data structure.
    Example: *Cube* (Object) –> *Mesh* –> *Material*

Toggle Pin ID
:   Click the pin icon to lock the editor to the current data-block, preventing it from changing when the selection
    updates. Click again to unlock and return to context-based display.

### Options

These options are accessible from the Options popover in the top-right corner of the editor.

Sync with Outliner
:   Controls whether clicking icons in the [Outliner](outliner/introduction.xhtml) changes the active tab.

    Always:
    :   Always follow the clicked Outliner icon.

    Never:
    :   Ignore Outliner interaction.

    Auto:
    :   Only follow when the Properties editor shares a border with the Outliner.

Visible Tabs
:   Allows hiding specific tabs in the Properties editor.

    This is especially useful for tailoring the editor to specific workflows. For example:
    - In the *Video Editing* workspace, you may hide object and shading tabs to reduce clutter.
    - In the *Modeling* workspace, you may hide strip-related tabs that are not relevant.

    Hidden tabs can be restored at any time using this filter list.
user: Show practical ways to work with Limbs Bones in a Blender add-on or script – include code.

assistant: While placing the arm bones try to start having a straight line that goes from
the shoulder to the hand in both front and top view. After this is done just add a slight bend to the elbow.
This can be easily done by going in the top view, entering armature Edit Mode and
sliding the bone junction between forearm and upper_arm slightly toward the world’s Y axis.

[image reference removed]

Arm Bones Positioning.

For the leg you can follow a similar process. Start by aligning the leg bones creating a straight line from
the hips to the ankle, then place the foot and the toe accordingly.
Remember to add a slight bend to the knee. This can be easily done by going in the side view,
entering armature Edit Mode and sliding the bone junction between thigh and shin slightly toward the world’s Y axis.

[image reference removed]

Leg Bones Positioning.

Finally align the heel bone by going in the front view and placing the head and tail to
fill the foot size from side to side. Then, in the side view,
align the bone at the point where the heel just touches the ground floor.
user: Give a detailed overview of Self-Collisions: syntax, arguments, return values, common patterns.

assistant: Real cloth cannot penetrate itself, so you normally want the cloth to self-collide.
Enable this to tell the cloth object that it should not penetrate itself.
This adds to the simulation’s compute time, but provides more realistic results.

Friction
:   A coefficient for how slippery the cloth is when it collides with itself.
    For example, silk has a lower coefficient of friction than cotton.

Distance
:   As cloth at this distance begins to repel away from itself.
    Smaller values might give errors but gives some speed-up while
    larger will give unrealistic results if too large and can be slow.
    It is best to find a good in between value.

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

Vertex Group
:   Faces that have all vertices assigned to this
    [Vertex Group](../../../modeling/meshes/properties/vertex_groups/index.xhtml) are excluded from self-collision.

### Troubleshooting

If you encounter some problems with collision detection, there are a few ways to fix them:

- The fastest solution is to increase the *Distance* for Object/Self Collisions.
  This will be the fastest way to fix the clipping; however, it will be less accurate and will not look as good.
  Using this method tends to make it look like the cloth is resting on air, and gives it a very rounded look.
- A second method is to increase the *Quality* (in the *Cloth* panel).
  This results in smaller steps for the simulator and
  therefore to a higher probability that fast-moving collisions get caught.
  You can also increase the Collisions *Quality* to perform more iterations to get collisions solved.
- If none of the methods help, you can easily edit the cached/baked result in *Edit Mode* afterwards.
- If the Cloth is torn by the deforming mesh; increase the stiffness settings.
user: How do I use Stiffness in Blender? Include parameters, examples, warnings and best practices.

assistant: To show the effect of the Stiffness setting, we will drop two cubes onto a plane
(see [Collisions](../collision.html)). The blue cube uses quads,
while the red one uses triangles. Both cubes have their Goal setting disabled.

If *Stiffness* is disabled, the quad-only cube will collapse completely,
while the tri cube only temporarily deforms from the impact:

Without Stiffness.

|  |  |  |
| --- | --- | --- |
| <../../../_images/physics_soft-body_forces_interior_quadvstri-sb-001.png>   Frame 1. | <../../../_images/physics_soft-body_forces_interior_quadvstri-sb-036.png>   Frame 36. | <../../../_images/physics_soft-body_forces_interior_quadvstri-sb-401.png>   Frame 401. |

If *Stiffness* is enabled, the quad cube maintains its shape as well thanks to the
extra springs:

With Stiffness.

|  |  |  |
| --- | --- | --- |
| <../../../_images/physics_soft-body_forces_interior_quadvstri-sb-001.png>   Frame 1. | <../../../_images/physics_soft-body_forces_interior_quadvstri-sb-sq-036.png>   Frame 36. | <../../../_images/physics_soft-body_forces_interior_quadvstri-sb-sq-401.png>   Frame 401. |
user: Explain Transform Geometry Node in complete detail according to the official Blender documentation.

assistant: # Transform Geometry Node

[image reference removed]

The *Transform Geometry Node* allows you to move, rotate or scale the geometry.
The transformation is applied to the entire geometry, and not per element.
The [Set Position Node](../write/set_position.xhtml) is used for moving
individual points of a geometry. For transforming instances individually, the instance
[translate](../../instances/translate_instances.xhtml),
[rotate](../../instances/rotate_instances.xhtml), or
[scale](../../instances/scale_instances.xhtml) nodes can be used.
user: Explain Shrinkwrap Modifier in complete detail according to the official Blender documentation.

assistant: # Shrinkwrap Modifier

The *Shrinkwrap* modifier allows a Grease Pencil object to “shrink” to the surface of another object.
It moves each point of the object being modified to the closest position on the surface of the given mesh.
user: Describe DisplaySafeAreas(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # DisplaySafeAreas(bpy_struct)

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

*class* bpy.types.DisplaySafeAreas(*bpy_struct*)
:   Safe areas used in 3D view and the sequencer

    action
    :   Safe area for general elements

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.035, 0.035)

    action_center
    :   Safe area for general elements in a different aspect ratio

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.15, 0.05)

    title
    :   Safe area for text and graphics

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.1, 0.05)

    title_center
    :   Safe area for text and graphics in a different aspect ratio

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [0, 1], default (0.175, 0.05)

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

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Constraint.name`](bpy.types.Constraint.html#bpy.types.Constraint.name "bpy.types.Constraint.name") - [`Constraint.type`](bpy.types.Constraint.html#bpy.types.Constraint.type "bpy.types.Constraint.type") - [`Constraint.is_override_data`](bpy.types.Constraint.html#bpy.types.Constraint.is_override_data "bpy.types.Constraint.is_override_data") - [`Constraint.owner_space`](bpy.types.Constraint.html#bpy.types.Constraint.owner_space "bpy.types.Constraint.owner_space") - [`Constraint.target_space`](bpy.types.Constraint.html#bpy.types.Constraint.target_space "bpy.types.Constraint.target_space") - [`Constraint.space_object`](bpy.types.Constraint.html#bpy.types.Constraint.space_object "bpy.types.Constraint.space_object") - [`Constraint.space_subtarget`](bpy.types.Constraint.html#bpy.types.Constraint.space_subtarget "bpy.types.Constraint.space_subtarget") | - [`Constraint.mute`](bpy.types.Constraint.html#bpy.types.Constraint.mute "bpy.types.Constraint.mute") - [`Constraint.enabled`](bpy.types.Constraint.html#bpy.types.Constraint.enabled "bpy.types.Constraint.enabled") - [`Constraint.show_expanded`](bpy.types.Constraint.html#bpy.types.Constraint.show_expanded "bpy.types.Constraint.show_expanded") - [`Constraint.is_valid`](bpy.types.Constraint.html#bpy.types.Constraint.is_valid "bpy.types.Constraint.is_valid") - [`Constraint.active`](bpy.types.Constraint.html#bpy.types.Constraint.active "bpy.types.Constraint.active") - [`Constraint.influence`](bpy.types.Constraint.html#bpy.types.Constraint.influence "bpy.types.Constraint.influence") - [`Constraint.error_location`](bpy.types.Constraint.html#bpy.types.Constraint.error_location "bpy.types.Constraint.error_location") - [`Constraint.error_rotation`](bpy.types.Constraint.html#bpy.types.Constraint.error_rotation "bpy.types.Constraint.error_rotation") |
user: What is Guides and how is it used in Blender Python scripting?

assistant: The following properties are only available when displaying the *Viewer Node* image
in the *Image Editor* set to *View* or *Mask* mode.

Text Info
:   Displays overlay text showing information about the active Viewer node:

    - **Render Size**: The resolution of the final render output.
      This is defined in the [Output Properties](../../render/output/properties/format.xhtml#bpy-types-rendersettings-resolution-x).
    - **Image Size**: The resolution of the image currently displayed in the Viewer node.

Render Region
:   Displays a border showing the final render region defined in the scene.
    Space outside the render region appear shaded for reference.

    Passepartout Alpha
    :   Controls the opacity of the shaded area outside the render region.
        Higher values darken the outside area more, making the render region stand out.
user: Explain Drawing Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

General drawing options.

Multiframe
:   Allows to draw on several frames at the same time.

    See [Multiframe](../../multiframe.xhtml) for more information.

Additive Drawing
:   When creating new frames adding strokes with drawing tools,
    the strokes from the previous/active frame are include as a basis for the new one.
    When erasing existing strokes using Additive Drawing a new keyframe will be added.

AutoMerge
:   Joins new strokes with the beginning or end of previously drawn strokes in the active layer.

Add Weight Data
:   When enabled, weight data is added to new strokes according to the current vertex group and weight.
    If there is no vertex group selected, no weight data is added.

    Useful for example in cut-out animation for adding new drawing
    on the same vertex group without the need to creating it afterwards.

    See [Weight Paint Mode](../weight_paint/introduction.xhtml) for more information.

Draw on Back
:   When enabled, new strokes are drawn below of all strokes in the layer.
    For example when you want to paint with a fill material below line strokes on a character and
    they are on the same layer.
user: Show practical ways to work with Fill in a Blender add-on or script – include code.

assistant: # Fill

The *Fill* option will create *triangular* faces from any group of selected edges
or vertices, as long as they form one or more complete perimeters.

Beauty
:   Arrange the new triangles nicely.

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

Filled using fill.

Note, unlike creating n-gons, *Fill* supports holes.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_face_fill_holes.png>   A closed perimeter of edges with holes. | <../../../../_images/modeling_meshes_editing_face_fill_holes-filled.png>   Filled using fill. |
user: Explain Aligning in complete detail according to the official Blender documentation.

assistant: # Aligning

These options allow you to align and orient the view.

Align View to Active
:   Aligns the view to a certain local axis of the active object, bone, or (in Edit Mode)
    the normal of the active face. The view also becomes orthographic.

    To return to the regular (untilted) perspective view, you can first press `Numpad3`
    to align to the global X axis, then orbit with `MMB`.

Align Active Camera to View `Ctrl`-`Alt`-`Numpad0`
:   Moves and rotates the active camera so it matches the current viewpoint.

Align Active Camera to Selected
:   Moves the active camera (without changing its orientation) so that its view
    frames the selected objects.

Center Cursor and Frame All `Shift`-`C`
:   Moves the [3D Cursor](../3d_cursor.xhtml) back to the world origin
    and changes the view so that you can see everything in your scene.

Center View to Cursor
:   Centers the view on the 3D Cursor.

View Lock to Active
:   Centers the view on the active object and makes it the point of interest. The view
    will continue orbiting around the object even if you pan to a different location.
    In addition, it will follow the object if it moves.

View Lock Clear
:   Returns the view to how it was before using *View Lock to Active*.
user: Explain Scenes in the Video Sequencer in complete detail according to the official Blender documentation.

assistant: Scenes can also be used as [Scene Strips](../../video_editing/edit/montage/strips/scene.xhtml) in the
[Video Sequencer](../../editors/video_sequencer/index.xhtml).
This allows you to composite or edit multiple scenes together in one timeline.

For example, each shot of an animation can be stored in its own scene,
and then combined in a master scene that uses scene strips to sequence them in order.
This workflow is useful for multi-shot projects, trailers,
or layout editing without the need to render intermediate files.

When used as strips, scenes are rendered dynamically during playback or rendering,
and they share the same data-blocks unless they were created as full copies.
user: Describe Color Fields from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Color fields. With and without alpha.

The color field stores a color value.
Clicking on it with `LMB` opens the [Color Picker](../templates/color_picker.xhtml).

Color fields with an alpha channel are divided in half: on the left, the color is shown without an alpha channel,
and on the right, it’s shown with an alpha channel over a checker pattern.

Colors can be copied to other color fields by dragging and dropping.

Hovering over a color property will display a large swatch preview of the color
and the color’s hexadecimal, RGBA, and HSVA values.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Output
:   Outputs the value from the input corresponding to the current *Index* value,
    without any modification.
    If the *Index* value is outside the range of available inputs, the output defaults
    to the first input or a zero-equivalent value, depending on the data type.
user: How do I use GeometryNodeSampleIndex(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSampleIndex(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.GeometryNodeSampleIndex(*GeometryNode*)
:   Retrieve values from specific geometry elements

    clamp
    :   Clamp the indices to the size of the attribute domain instead of outputting a default value for invalid indices

        Type:
        :   boolean, default False

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    domain
    :   Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Image
:   The default image input for the node group, available when the group is created.
    It can be used to feed images or render layers into the group.

Any additional inputs defined in the node group’s interface will appear here as output sockets.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: - Nodes can be added to a frame by dragging them inside it.
- Moving the frame also moves all contained nodes.
- Frames can be resized by dragging the corners or edges.
- The frame can display a custom label, useful for naming sections of your node setup.
user: Describe ShaderNodeValToRGB(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeValToRGB(ShaderNode)

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

*class* bpy.types.ShaderNodeValToRGB(*ShaderNode*)
:   Map values to colors with the use of a gradient

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

    *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: Show practical ways to work with Viewport Render in a Blender add-on or script – include code.

assistant: # Viewport Render

Viewport rendering lets you create quick preview renders from the current viewpoint
(rather than from the active camera, as would be the case with a regular render).

You can use *Viewport Render* to render both images and animations.

Below is a comparison between the Viewport render and a final render using
the Cycles Renderer.

Model by © 2016 pokedstudio.com

|  |  |  |
| --- | --- | --- |
| ../../_images/editors_3dview_viewport-render_example-workbench-render.jpg   Viewport render using Solid Mode. | ../../_images/editors_3dview_viewport-render_example-eevee-render.jpg   Viewport render using Material Preview Mode. | ../../_images/editors_3dview_viewport-render_example-cycles-render.jpg   Full render. |
user: What is ThemeCommon(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ThemeCommon(bpy_struct)

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

*class* bpy.types.ThemeCommon(*bpy_struct*)
:   Theme properties shared by different editors

    anim
    :   Type:
        :   [`ThemeCommonAnim`](bpy.types.ThemeCommonAnim.html#bpy.types.ThemeCommonAnim "bpy.types.ThemeCommonAnim"), (readonly, never None)

    curves
    :   Type:
        :   [`ThemeCommonCurves`](bpy.types.ThemeCommonCurves.html#bpy.types.ThemeCommonCurves "bpy.types.ThemeCommonCurves"), (readonly, never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The mask display can be toggled as a [viewport overlay](../../../editors/3dview/display/overlays.xhtml).
In the overlay popover, the opacity of the mask overlay can be adjusted to make it more or less visible on the mesh.
user: Provide the full official documentation entry for Common Problems, preserving all code examples.

assistant: ### Unsupported Graphics Driver Error

This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.

### Crash on Startup

Try running Blender from the [command line](../../../advanced/command_line/index.html), 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.

### Poor Performance

- Update your graphics drivers (see above).
- On laptops, make sure you are using a dedicated GPU (see above).
- Try lowering quality settings in Preferences ‣ System ‣ Memory & Limits.
- Try undoing settings in your graphics drivers, if you made any changes there.

### Render Errors

See [EEVEE](../../../render/eevee/limitations/index.html) and [Cycles](../../../render/cycles/gpu_rendering.html) documentation
respectively.

### Wrong Selection in 3D Viewport

See [Invalid Selection, Disable Anti-Aliasing](../../3d_view.html#troubleshooting-3dview-invalid-selection).

### Virtual Machines

Running Blender inside a virtual machine is known to have problems when OpenGL drawing calls are forwarded to the host
operating system.

To resolve this, configure the system to use PCI passthrough.

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

In *Pose Mode*, bones behave like objects. So the transform actions
(move, rotate, scale, etc.) are very similar to the same ones in Object Mode
(all available ones are regrouped in the Pose ‣ Transform submenu). However,
there are some important specifics:

- Bones’ relationships are crucial (see [Bone Parenting](../../bones/properties/relations.xhtml#bpy-types-editbone-parent)).
- The “transform center” of a given bone
  (i.e. its default pivot point, when it is the only selected one) is *its root*.
  Note by the way that some pivot point options seem to not work properly. In fact,
  except for the *3D Cursor* one, all others appear to always use the median point of the selection
  (and not e.g. the active bone’s root when *Active Object* is selected, etc.).
user: Show practical ways to work with Clump Hair Curves in a Blender add-on or script – include code.

assistant: # Clump Hair Curves

The *Clump Hair Curves* node gathers nearby hair curves together around designated guide curves,
creating clump formations commonly seen in real hair, fur, and grass.
It is a key step in grooming workflows for adding realism and structure by simulating
how strands naturally group due to moisture, product, or physical interaction.
user: How do I use GeometryNodeToolSelection(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeToolSelection(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.GeometryNodeToolSelection(*GeometryNode*)
:   User selection of the edited geometry, for tool execution

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: As previously noted, bones’ transformations are performed based on the *Rest Position* of
the armature, which is its state as defined in *Edit Mode*. This means that in
rest position, in *Pose Mode*, each bone has a scale of 1.0, and null rotation
and position (as you can see it in the *Transform* panel, in the 3D Viewport’s Sidebar).

[image reference removed]

An example of a rotation locked to the local Y axis, with two bones selected.

Note that the two green lines materializing the axes are centered on the armature’s center,
and not each bone’s root…

Moreover, the local space for these actions is the bone’s own one
(visible when you enable the *Axes* option of the *Armature* panel).
This is especially important when using axis locking, for example,
there is no specific “bone roll” tool in *Pose Mode*,
as you can rotate around the bone’s main axis just by locking on the local Y axis
`R` `Y` `Y`… This also works with several bones selected;
each one is locked to its own local axis!

When you pose your armature,
you are supposed to have one or more objects skinned on it! And obviously,
when you transform a bone in *Pose Mode*,
its related objects or object’s shape is moved/deformed accordingly, in real-time.
Unfortunately, if you have a complex rig set-up and/or a heavy skin object,
this might produce lag during interactive editing.
If you experience such troubles, try enabling the *Delay Deform* button in
the *Armature* panel the skin objects will only be updated once you confirm
the transform operation.
user: Explain bpy_prop_collection in complete detail according to the official Blender documentation.

assistant: # bpy_prop_collection

*class* bpy.types.bpy_prop_collection
:   built-in class used for all collections.

    find(*key*)
    :   Returns the index of a key in a collection or -1 when not found
        (matches Python’s string find function of the same name).

        Parameters:
        :   **key** (*str*) – The identifier for the collection member.

        Returns:
        :   index of the key.

        Return type:
        :   int

    foreach_get(*attr*, *seq*)
    :   This is a function to give fast access to attributes within a collection.

        Only works for ‘basic type’ properties (bool, int and float)!
        Multi-dimensional arrays (like array of vectors) will be flattened into seq.

        ```
        collection.foreach_get(attr, some_seq)

        # Python equivalent.
        for i in range(len(seq)):
            some_seq[i] = getattr(collection[i], attr)
        ```

    foreach_set(*attr*, *seq*)
    :   This is a function to give fast access to attributes within a collection.

        Only works for ‘basic type’ properties (bool, int and float)!
        seq must be uni-dimensional, multi-dimensional arrays (like array of vectors) will be re-created from it.

        ```
        collection.foreach_set(attr, some_seq)

        # Python equivalent.
        for i in range(len(some_seq)):
            setattr(collection[i], attr, some_seq[i])
        ```

    get(*key*, *default=None*)
    :   Returns the value of the item assigned to key or default when not found
        (matches Python’s dictionary function of the same name).

        Parameters:
        :   - **key** (*str*) – The identifier for the collection member.
            - **default** (*Any*) – Optional argument for the value to return if
              *key* is not found.

    items()
    :   Return the identifiers of collection members
        (matching Python’s dict.items() functionality).

        Returns:
        :   (key, value) pairs for each member of this collection.

        Return type:
        :   list[tuple[str, [`bpy.types.bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")]]

    keys()
    :   Return the identifiers of collection members
        (matching Python’s dict.keys() functionality).

        Returns:
        :   the identifiers for each member of this collection.

        Return type:
        :   list[str]

    values()
    :   Return the values of collection
        (matching Python’s dict.values() functionality).

        Returns:
        :   The members of this collection.

        Return type:
        :   list[[`bpy.types.bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct") | None]
user: Provide the full official documentation entry for Close, preserving all code examples.

assistant: Close or open strokes by connecting the last and first point.

Type
:   Close All:
    :   Close all open selected strokes.

    Open All:
    :   Open all closed selected strokes.

    Toggle:
    :   Close or Open selected strokes as required.

Match Point Density
:   Add point in the new segment to keep the same density.
user: How do I use Evaluate Closure in Blender? Include parameters, examples, warnings and best practices.

assistant: # Evaluate Closure

[image reference removed]

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

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

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: Explain Wind in complete detail according to the official Blender documentation.

assistant: # Wind

[image reference removed]

Wind force field visualization.

The *Wind* force field gives a constant force in a single direction, along the force object’s local Z axis.
The strength of the force is visualized by the spacing of the circles shown.

[image reference removed]

UI for a Wind force field.
user: Describe NodeTreeInterfaceSocketFloat(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

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

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # SpacePreferences(Space)

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

*class* bpy.types.SpacePreferences(*Space*)
:   Blender preferences space data

    filter_text
    :   Search term for filtering in the UI

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

    filter_type
    :   Filter method

        - `NAME`
          Name – Filter based on the operator name.
        - `KEY`
          Key-Binding – Filter based on key bindings.

        Type:
        :   enum in [`'NAME'`, `'KEY'`], default `'NAME'`

    show_region_ui
    :   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

    *classmethod* draw_handler_add(*callback*, *args*, *region_type*, *draw_type*)
    :   Add a new draw handler to this space type.
        It will be called every time the specified region in the space type will be drawn.
        Note: All arguments are positional only for now.

        Parameters:
        :   - **callback** (*Callable**[**...**,* *Any**]*) – A function that will be called when the region is drawn.
              It gets the specified arguments as input, it’s return value is ignored.
            - **args** (*tuple**[**Any**,* *...**]*) – Arguments that will be passed to the callback.
            - **region_type** (*str*) – The region type the callback draws in; usually `WINDOW`. ([`bpy.types.Region.type`](bpy.types.Region.html#bpy.types.Region.type "bpy.types.Region.type"))
            - **draw_type** (*str*) – Usually `POST_PIXEL` for 2D drawing and `POST_VIEW` for 3D drawing. In some cases `PRE_VIEW` can be used. `BACKDROP` can be used for backdrops in the node editor.

        Returns:
        :   Handler that can be removed later on.

        Return type:
        :   object

    *classmethod* draw_handler_remove(*handler*, *region_type*)
    :   Remove a draw handler that was added previously.

        Parameters:
        :   - **handler** (*object*) – The draw handler that should be removed.
            - **region_type** (*str*) – Region type the callback was added to.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Bricks 1, Bricks 2
:   Sets the color range of the bricks. Brick colors are chosen randomly between these two colors.

Mortar
:   Sets the mortar color, in between the bricks.

Thickness
:   Sets the thickness of the mortar.

Bias
:   The bias of randomly chosen colors,
    between (-1 to 1). -1 Makes all bricks Color 1, and a value of 1 makes them all Color 2.

Brick Width
:   Sets the horizontal size of all the bricks.

Row Height
:   Sets the vertical size of all the bricks.
user: What is Display and how is it used in Blender Python scripting?

assistant: Text Info Overlay
:   Object Info
    :   Display the active Object name and frame number at the top left of the 3D Viewport.

    View Name
    :   Display the name and type of the current view in the top left corner of the 3D Viewport.
        For example: “User Perspective” or “Top Orthographic”.

Playback Frame Rate (FPS)
:   Show the frames per second screen refresh rate while an animation is played back.
    It appears in the top left of the 3D Viewport, displaying red if the frame rate set cannot be reached.

    Frame Rate Samples
    :   Calculate the FPS displayed in the viewport based on an average of the current and previously displayed frames.
        A value of zero uses the number of frames in 1.0 second.

        - More samples represent the average FPS over a longer period of time,
          however sudden changes to performance result in a more gradual increase/decrease over time.
        - Fewer samples shows an FPS which more closely matches the actual performance,
          however the value may jitter - making the FPS difficult to comprehend.

Gizmo Size
:   Diameter of the gizmo.

HDRI Preview Size
:   Diameter of the HDRI sphere overlay.

3D Viewport Axes
:   Interactive Navigation:
    :   Display the axis as an interactive gizmo.
        Click sets the viewport to display along this axis and dragging orbits the view.

    Simple Axes:
    :   Display simple, less intrusive axis in the viewport.

        Brightness
        :   How vivid the colors of the simple axis are.

    Off:
    :   Disables the viewport axis.

Size
:   Diameter of the *3D Viewport Axis* widget.

Fresnel – Edit Mode
:   Enable a fresnel effect on edit mesh overlays.
    It improves shape readability of very dense meshes, but increases eye fatigue when modeling lower poly.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Image
:   Standard color input image.

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

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

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

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

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

Preserve Colors
:   Maintains natural color balance when applying tonal adjustments.
    When disabled, contrast and clarity may shift the color hue or saturation.
user: How do I use UVs Explained in Blender? Include parameters, examples, warnings and best practices.

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

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

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

### Example

[[image reference removed]](../../_images/editors_uv_introduction_3d-uv-space.png)

3D space (XYZ) versus UV space.

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

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

You’ll typically want to minimize this distortion by manually guiding and tweaking
the flattening, using [seams](../../modeling/meshes/uv/unwrapping/seams.html) for example.
However, it’s not always possible to eliminate it completely.
user: How do I use Lennard-Jones in Blender? Include parameters, examples, warnings and best practices.

assistant: # Lennard-Jones

The *Lennard-Jones* force field is a very short range force with a behavior determined by the sizes of the effector
and effected particle. At a distance smaller than the combined sizes, the field is very
repulsive and after that distance it is attractive.
It tries to keep the particles at an equilibrium distance from each other.
Particles need to be at a close proximity to each other to be effected by this field at all.

Particles can have for example both a charge and a Lennard-Jones potential,
which is probably something for the nuclear physicists among us.

[image reference removed]

UI for a Lennard-Jones force field.