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

assistant: Select
:   Click `LMB` to select a single item. Additionally hold `Ctrl` to add/remove that item
    to/from the selection, or `Shift` to select a range of items.

Dragging
:   Dragging with `LMB` starts a [box selection](../interface/selecting.html#tool-select-box).

### Arrow Keys

It is also possible to select/deselect files by “walking” through them using the arrow keys:

- Press an arrow key to select the next/previous file in the list and deselect all the others.
- Hold `Shift` to keep the current selection (and add to it).
- Hold `Shift`-`Ctrl` to invert the selection as you pass over it.

If no file is selected, the arrow key navigation selects the first or last file in the directory,
depending on the arrow direction.
user: Give a detailed overview of Keyframe Handle Type Items: syntax, arguments, return values, common patterns.

assistant: # Keyframe Handle Type Items

FREE:
:   Free.

    Completely independent manually set handle.

ALIGNED:
:   Aligned.

    Manually set handle with rotation locked together with its pair.

VECTOR:
:   Vector.

    Automatic handles that create straight lines.

AUTO:
:   Automatic.

    Automatic handles that create smooth curves.

AUTO_CLAMPED:
:   Auto Clamped.

    Automatic handles that create smooth curves which only change direction at keyframes.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Root Selection
:   A boolean selection that is `true` only for the root points of curves.
    This is useful for applying operations exclusively at the curve base.

Root Position
:   The position of each curve’s root point in 3D space.
    This can be used for aligning objects, sampling data from a surface, or generating root-based effects.

Root Direction
:   A normalized vector representing the direction of the first segment of the curve,
    pointing away from the root toward the next control point.
    This is useful for orienting instances or determining the initial growth direction of the curve.

Root Index
:   The index of the root point for each curve.
    This is typically 0 for every curve, but it can be used to identify root points
    when processing multiple curves together.
user: Show practical ways to work with Notes in a Blender add-on or script – include code.

assistant: It is possible that this node will put out a value set that has values beyond the normal range,
i.e. values greater than one and less than zero.
If you will be using the output to mix with other images in the normal range,
you should clamp the values using the Map Value node (with the Min and Max enabled),
or put through a Color Ramp node (with all normal defaults).

[image reference removed]

Clamp the values to normal range.

Either of these nodes will scale the values back to normal range.
In the example image, we want to intensify the specular pass.
The bottom thread shows what happens if we do not clamp the values;
the specular pass has a value much less than one in the dark areas;
when added to the medium gray, it makes black. Passing the brightened image through either
the Map Value or the Color Ramp node produces the desired effect.
user: Give a detailed overview of Checkboxes & Toggle Buttons: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Checkboxes and Toggle buttons.

These controls are used to activate or deactivate options.
Use `LMB` to change their state. A tick is shown on checkboxes when
the option is activated. Active status on toggle buttons is indicated
either by color on the icon background, or a change in icon graphics.

Use `Ctrl`-`Wheel` to cycle through on/off states.

### Dragging

To change many values at once on or off, you can press down
`LMB` and drag over multiple buttons.
user: What is Bpy.Types.Curvemapping and how is it used in Blender Python scripting?

assistant: .curve LineStyleThicknessModifier_DistanceFromCamera.curve LineStyleThicknessModifier_DistanceFromObject.curve LineStyleThicknessModifier_Material.curve LineStyleThicknessModifier_Tangent.curve Paint.cavity_curve ParticleBrush.curve ParticleSettings.clump_curve ParticleSettings.roughness_curve ParticleSettings.twist_curve RenderSettings.motion_blur_shutter_curve Sculpt.automasking_cavity_curve Sculpt.automasking_cavity_curve_op ShaderNodeFloatCurve.mapping ShaderNodeRGBCurve.mapping ShaderNodeVectorCurve.mapping TextureNodeCurveRGB.mapping TextureNodeCurveTime.curve UvSculpt.curve_distance_falloff VertexWeightEditModifier.map_curve VertexWeightProximityModifier.map_curve WarpModifier.falloff_curve Next CurveModifier(Modifier) Previous CurveMapPoints(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page CurveMapping(bpy_struct) CurveMapping CurveMapping.black_level CurveMapping.clip_max_x CurveMapping.clip_max_y CurveMapping.clip_min_x CurveMapping.clip_min_y CurveMapping.curves CurveMapping.extend CurveMapping.tone CurveMapping.use_clip CurveMapping.white_level CurveMapping.update() CurveMapping.reset_view() CurveMapping.initialize() CurveMapping.evaluate() CurveMapping.bl_rna_get_subclass() CurveMapping.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`MovieTracking.plane_tracks`](bpy.types.MovieTracking.html#bpy.types.MovieTracking.plane_tracks "bpy.types.MovieTracking.plane_tracks") - [`MovieTrackingObject.plane_tracks`](bpy.types.MovieTrackingObject.html#bpy.types.MovieTrackingObject.plane_tracks "bpy.types.MovieTrackingObject.plane_tracks") | - [`MovieTrackingPlaneTracks.active`](bpy.types.MovieTrackingPlaneTracks.html#bpy.types.MovieTrackingPlaneTracks.active "bpy.types.MovieTrackingPlaneTracks.active") |
user: What is Volume Grid Data Type Items and how is it used in Blender Python scripting?

assistant: # Volume Grid Data Type Items

BOOLEAN:
:   Boolean.

    Boolean.

FLOAT:
:   Float.

    Single precision float.

DOUBLE:
:   Double.

    Double precision.

INT:
:   Integer.

    32-bit integer.

INT64:
:   Integer 64-bit.

    64-bit integer.

MASK:
:   Mask.

    No data, boolean mask of active voxels.

VECTOR_FLOAT:
:   Vector.

    3D float vector.

VECTOR_DOUBLE:
:   Double Vector.

    3D double vector.

VECTOR_INT:
:   Integer Vector.

    3D integer vector.

POINTS:
:   Points (Unsupported).

    Points grid, currently unsupported by volume objects.

UNKNOWN:
:   Unknown.

    Unsupported data type.
user: Provide the full official documentation entry for FunctionNodeRotateVector(FunctionNode), preserving all code examples.

assistant: # FunctionNodeRotateVector(FunctionNode)

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

*class* bpy.types.FunctionNodeRotateVector(*FunctionNode*)
:   Apply a rotation to a given vector

    *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 Checker Deselect, preserving all code examples.

assistant: Deselects control points according to a repeating pattern, starting at the active point.
For example, if *Deselected* is set to 2 and *Selected* to 3, the operator will
deselect the first two consecutive points, leave the next three unchanged, deselect
the two that come after those, and so on. This is done in both the “horizontal” and
“vertical” direction of the grid.

Deselected
:   The number of control points to deselect in each pattern repetition.

Selected
:   The number of control points to leave unchanged in each pattern repetition.

Offset
:   Offset from the starting point.
user: Describe Rotation Modes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Rotation Modes

Blender lets you define rotations in several ways. Each one of them has a series of advantages and drawbacks;
there is no best rotation mode, as each one is suitable for specific cases.

In all of these modes, positive angle values mean counter-clockwise rotation direction,
while negative values define clockwise rotation.

Though you can rotate elements using the global or local transform orientations,
these axes are not suitable to define rotations, as the effect of each of
them cannot be isolated from the other two.

Take, for instance, any three values for X, Y and Z rotation. Perform each one of these using global or local axes.
Depending on the order in which you perform these, you will end up with different final orientations.
So proper rotation coordinate systems are needed.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`GreasePencilDrawing.attributes`](bpy.types.GreasePencilDrawing.html#bpy.types.GreasePencilDrawing.attributes "bpy.types.GreasePencilDrawing.attributes") | - [`GreasePencilDrawing.color_attributes`](bpy.types.GreasePencilDrawing.html#bpy.types.GreasePencilDrawing.color_attributes "bpy.types.GreasePencilDrawing.color_attributes") |
user: Show practical ways to work with Single Image in a Blender add-on or script – include code.

assistant: ```
blender -b file.blend -f 10
```

`-b`
:   Render in the background (without UI).

`file.blend`
:   Path to the blend-file to render.

`-f 10`
:   Render only the 10th frame.

```
blender -b file.blend -o /project/renders/frame_##### -F OPEN_EXR -f -2
```

`-o /project/renders/frame_#####`
:   Path of where to save the rendered image, using five padded zeros for the frame number.

`-F OPEN_EXR`
:   Override the image format specified in the blend-file and save to an OpenEXR image.

`-f -2`
:   Render only the second last frame.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: This add-on allows you to export a UV map as an image:
(UV Editor ‣ UV ‣ Export UV Layout)
It allows you to export to `PNG`, `EPS`, or `SVG` format.
The desired UV faces must be selected in the 3D View, not the UV Editor.

The image will be lines defining the UV edges that are within the default grid of the UV Editor.
Edges outside this boundary, even if selected, will not be shown in the saved graphic.

You can then bring this image into your favorite painting program,
and use it as a transparent reference guide to create a texture.
Then export that image and load it back into Blender as part of a material set-up.
For using images as textures, see the page on
[Image Textures](../../render/materials/legacy_textures/types/image_movie.html).

|  |  |
| --- | --- |
| <../../_images/addons_import-export_mesh-uv-layout_uv-editor.png>   A UV layout in the UV Editor. | <../../_images/addons_import-export_mesh-uv-layout_export.png>   A UV layout in a paint program. |
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Each tool has the following settings to change how the unmasked mesh will be transformed.

Transform Mode
:   How the transformation is going to be applied to the target.

    All Vertices:
    :   Applies the transformation to all vertices in the mesh.

    Elastic:
    :   Applies the transformation while dynamically simulating elasticity.
        Instead of applying this to all vertices, it uses the radius of the cursor as the area of effect.
user: Explain NodeClosureOutputItems(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # NodeClosureOutputItems(bpy_struct)

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

*class* bpy.types.NodeClosureOutputItems(*bpy_struct*)
:   new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

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

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

    *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 X/Y/Z Local in complete detail according to the official Blender documentation.

assistant: These operations perform a non-interactive mirror along the object’s local axes.

X Local
:   Mirrors the selection along the object’s local X axis.

Y Local
:   Mirrors the selection along the object’s local Y axis.

Z Local
:   Mirrors the selection along the object’s local Z axis.
user: How do I use UDIMTile(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # UDIMTile(bpy_struct)

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

*class* bpy.types.UDIMTile(*bpy_struct*)
:   Properties of the UDIM tile

    channels
    :   Number of channels in the tile pixels buffer

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

    generated_color
    :   Fill color for the generated image

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0)

    generated_height
    :   Generated image height

        Type:
        :   int in [1, 65536], default 0

    generated_type
    :   Generated image type

        Type:
        :   enum in [Image Generated Type Items](bpy_types_enum_items/image_generated_type_items.html#rna-enum-image-generated-type-items), default `'BLANK'`

    generated_width
    :   Generated image width

        Type:
        :   int in [1, 65536], default 0

    is_generated_tile
    :   Is this image tile generated

        Type:
        :   boolean, default False, (readonly)

    label
    :   Tile label

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

    number
    :   Number of the position that this tile covers

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

    size
    :   Width and height of the tile buffer in pixels, zero when image data cannot be loaded

        Type:
        :   int array of 2 items in [-inf, inf], default (0, 0), (readonly)

    use_generated_float
    :   Generate floating-point buffer

        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: Describe ParticleBrush(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ParticleBrush(bpy_struct)

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

*class* bpy.types.ParticleBrush(*bpy_struct*)
:   Particle editing brush

    count
    :   Particle count

        Type:
        :   int in [1, 1000], default 10

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

    length_mode
    :   - `GROW`
          Grow – Make hairs longer.
        - `SHRINK`
          Shrink – Make hairs shorter.

        Type:
        :   enum in [`'GROW'`, `'SHRINK'`], default `'GROW'`

    puff_mode
    :   - `ADD`
          Add – Make hairs more puffy.
        - `SUB`
          Sub – Make hairs less puffy.

        Type:
        :   enum in [`'ADD'`, `'SUB'`], default `'ADD'`

    size
    :   Radius of the brush in pixels

        Type:
        :   int in [1, 32767], default 50

    steps
    :   Brush steps

        Type:
        :   int in [1, 32767], default 10

    strength
    :   Brush strength

        Type:
        :   float in [0.001, 1], default 0.5

    use_puff_volume
    :   Apply puff to unselected end-points (helps maintain hair volume when puffing root)

        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: Describe GeometryNodeBlurAttribute(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeBlurAttribute(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.GeometryNodeBlurAttribute(*GeometryNode*)
:   Mix attribute values of neighboring elements

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

    *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 KeyingSetInfo(bpy_struct), preserving all code examples.

assistant: # KeyingSetInfo(bpy_struct)

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

*class* bpy.types.KeyingSetInfo(*bpy_struct*)
:   Callback function defines for builtin Keying Sets

    bl_description
    :   A short description of the keying set

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

    bl_idname
    :   If this is set, the Keying Set gets a custom ID, otherwise it takes the name of the class used to define the Keying Set (for example, if the class name is “BUILTIN_KSI_location”, and bl_idname is not set by the script, then bl_idname = “BUILTIN_KSI_location”)

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

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

    bl_options
    :   Keying Set options to use when inserting keyframes

        Type:
        :   enum set in [Keying Flag Items](bpy_types_enum_items/keying_flag_items.html#rna-enum-keying-flag-items), default set()

    poll(*context*)
    :   Test if Keying Set can be used or not

        Return type:
        :   boolean

    iterator(*context*, *ks*)
    :   Call generate() on the structs which have properties to be keyframed

    generate(*context*, *ks*, *data*)
    :   Add Paths to the Keying Set to keyframe the properties of the given data

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

assistant: Tripod
:   Tripod Motion can be used for footage where the camera does not move and only rotates.
    Such footage can’t be tracked with a generic solver approach, and
    it is impossible to determine the actual feature points in space due to a lack of information.
    So this solver will solve only the relative camera rotation and then reproject the feature points into a sphere,
    with the same distance between feature and camera for all feature points.

Keyframe
:   Automatically select keyframes for initial reconstruction.
    This option enables complex algorithms which tries to find a keyframe pair
    with minimal reconstruction error and best scene scale guess.

Keyframe A/B
:   Start (A) and End (B) frame of the range used for reconstruction.

Refine
:   Specifies which parameters should be refined during solve.
    Such refining is useful when you are not sure about some camera intrinsics,
    and solver should try to find the best parameter for those intrinsics.
    But you still have to know approximate initial values –
    it will fail to find correct values if they were set completely incorrectly initially.

    Focal Length
    :   Refine the camera’s [Focal Length](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-focal-length).

    Optical Center
    :   Refine the camera’s [Optical Center](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-principal-point).

    Radial Distortion
    :   Refine the camera’s [Radial Distortion Parameters](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-k).

    Tangential Distortion
    :   Refine the camera’s [Tangential Distortion Parameters](../sidebar/track/camera.xhtml#bpy-types-movietrackingcamera-brown-p).

Solve Camera/Object Motion
:   See [Solve Camera/Object Motion](../editing/track.xhtml#bpy-ops-clip-solve-camera).
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Sculpting and painting offers a more freeform workflow of editing via [brushes](brush/index.xhtml).
There are several [modes](../editors/3dview/modes.xhtml) to do this, each with their own purpose.

- [Sculpting](sculpting/introduction/general.xhtml):
  Change and transform the topology of your mesh.
- [Vertex Paint](vertex_paint/introduction.xhtml):
  Change the color of vertices in the active Color Attribute.
- [Weight Paint](weight_paint/introduction.xhtml):
  Change the weight of vertices in the active vertex group.
- [Texture Paint](texture_paint/introduction.xhtml):
  Change the pixels of the active image texture.
user: Provide the full official documentation entry for ViewLayerEEVEE(bpy_struct), preserving all code examples.

assistant: # ViewLayerEEVEE(bpy_struct)

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

*class* bpy.types.ViewLayerEEVEE(*bpy_struct*)
:   View Layer settings for EEVEE

    ambient_occlusion_distance
    :   Distance of object that contribute to the ambient occlusion effect

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

    use_pass_bloom
    :   Deliver bloom pass (deprecated)

        Type:
        :   boolean, default False

    use_pass_transparent
    :   Deliver alpha blended surfaces in a separate pass

        Type:
        :   boolean, default False

    use_pass_volume_direct
    :   Deliver volume direct light pass

        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: How do I use [Local Editing](local_editing/index.html) in Blender? Include parameters, examples, warnings and best practices.

assistant: Edit manual files on your computer using a plain text editor.
Files are synchronized with the online version through a repository, ensuring your local edits remain up-to-date.

Local editing also lets you build and preview your changes before submitting.
user: How do I use Show/Hide in Blender? Include parameters, examples, warnings and best practices.

assistant: # Show/Hide

Show Hidden Objects `Alt`-`H`
:   Reveals all hidden objects.

Hide Selected `H`
:   Hides all selected objects.

Hide Unselected `Shift`-`H`
:   Hides all unselected objects of the scene.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`FunctionNodeFormatString.format_items`](bpy.types.FunctionNodeFormatString.html#bpy.types.FunctionNodeFormatString.format_items "bpy.types.FunctionNodeFormatString.format_items") |  |
user: How do I use High Viscosity Solver in Blender? Include parameters, examples, warnings and best practices.

assistant: The high viscosity liquid solver can be used to simulate fluids with increased viscosity,
replicating the behavior of substances like honey or molasses.
This specialized solver enhances the accuracy of slow-moving and thick liquid simulations.

Strength
:   The viscosity of the liquid. Higher values result in more viscous fluids.

    Rotating liquid inflow with varying viscosities.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_liquid_viscosity_0-2.png   Strength of 0.2 (at frame 65). | ../../../../../_images/physics_fluid_type_domain_liquid_viscosity_0-4.png   Strength of 0.4 (at frame 200). |
user: What is Graph View and how is it used in Blender Python scripting?

assistant: # Graph View

The graph or curves view has numerous purposes based on the color of the lines.
The red and green lines on the graph show you the speed of the trackers at a given frame.
Green is vertical movement, Red is horizontal. Therefore the first frames will always be at zero.

The blue line is the line that comes out when you click on the film strip is the average per-frame error.
This curve is available only after pressing camera solve and is not editable.
This is the one line that you want to be as flat as possible and as closer to zero as you can.
The high points will show you where in your shot you are having inaccurate tracking.

Frames outside of scene frame range are darkened.

[image reference removed]

Graph View.
user: Describe GeometryNodeSampleNearest(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeSampleNearest(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.GeometryNodeSampleNearest(*GeometryNode*)
:   Find the element of a geometry closest to a position. Similar to the “Index of Nearest” node

    domain
    :   Type:
        :   enum in [Attribute Domain Only Mesh Items](bpy_types_enum_items/attribute_domain_only_mesh_items.html#rna-enum-attribute-domain-only-mesh-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: Describe NodeSocketVectorDirection2D(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeSocketVectorDirection2D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorDirection2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Edge Split Modifier in a Blender add-on or script – include code.

assistant: # Edge Split Modifier

The *Edge Split* modifier splits, duplicates edges within a mesh,
breaking ‘links’ between faces around those split edges.

The edges to split can be determined from the edge angle (i.e. angle between faces forming that edge),
and/or edges marked as sharp.

Splitting an edge affects vertex normal generation at that edge, making the edge appear sharp.
It can also be used for manual control of the smoothing process,
where the user defines which edges should appear smooth or sharp
(see [Mesh Smoothing](../../meshes/editing/mesh/shading.html#modeling-meshes-editing-normals-shading) for other ways to do this).
If desired, both modes can be active at once.
user: Show practical ways to work with Technical Terms in a Blender add-on or script – include code.

assistant: In general, the technical terms used in computer graphics are quite new or even downright neologisms invented for the
needs, so they do not always have a translation in your language. Moreover, a large part of Blender users use its
English interface.

As a result, unless a term has an evident translation, you should preferably use the English one, *putting it in
italic*. You can then find a translation for it, which you will use from times to times (e.g. to avoid
repetitions…). This is also valid in the other way: even when a term has a straightforward translation, do not
hesitate to use its English version from times to times, to get the reader used with it…

If a term is definitively not translatable, simply use the English one, but make sure its glossary entry is
translated.

In the glossary, the English term is written first (to maintain alphabetic order) with the translated entry following
in parenthesis, when appropriate.
user: Provide the full official documentation entry for Separate Spherical Node, preserving all code examples.

assistant: # Separate Spherical Node

[image reference removed]

The *Separate Spherical* node converts a vector from Cartesian coordinates (X, Y, Z)
into spherical coordinates (R, Φ, Θ) and outputs each component separately.
It is the inverse of the [Combine Spherical](combine_spherical.xhtml) node.

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: Explain Specials in complete detail according to the official Blender documentation.

assistant: Show All
:   Unhides any hidden bone collections.

Un-Solo All
:   Clear the ‘solo’ setting on all bone collections

Remove Unused
:   Remove all bone collections that have neither bones nor children.
    This is done recursively, so bone collections that only have unused children are also removed.
user: Give a detailed overview of Bpy.Types.Shadernodebsdfhairprincipled: syntax, arguments, return values, common patterns.

assistant: dfHairPrincipled.bl_rna_get_subclass() ShaderNodeBsdfHairPrincipled.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Value
:   The Gabor noise value with both random intensity and phase. This is equal to sine the phase
    multiplied by the intensity.

Phase
:   The phase of the Gabor noise, which has no random intensity.

Intensity
:   The intensity of the Gabor noise, which has no random phase.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Noise Basis
:   The texture to be distorted.

Distortion
:   The texture to use to distort another.

Amount
:   The amount that *Distortion Noise* affects *Basis*.

Size
:   The size of the noise generated.

Nabla
:   Almost all procedural textures in Blender use derivatives for calculating normals for texture mapping
    (except *Blend* and *Magic*). This is important for Normal and Displacement Maps.
    The strength of the effect is controlled with the *Nabla* number field.
user: Describe GeometryNodeImportSTL(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeImportSTL(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.GeometryNodeImportSTL(*GeometryNode*)
:   Import a mesh from an STL file

    *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 Toolbar in a Blender add-on or script – include code.

assistant: # Toolbar

Selection tools
:   [Tweak](../../../interface/selecting.xhtml#tool-select-tweak)
    :   Select or move.

    [Select Box](../../../interface/selecting.xhtml#tool-select-box)
    :   Select strips by dragging a box.
        All strips that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.xhtml#tool-select-circle)
    :   Select strips by dragging a circle. All strips that intersect the path of
        the circle will be selected.

    [Select Lasso](../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select strips by drawing a lasso.

Blade
:   Cuts a strip in two. Specifically, it first shortens the strip so it only shows the content
    up to the cut point, then adds a second strip that shows the content after the cut point.

    Splitting be done in two different ways:

    - Select the tool in the Toolbar and click a strip at the time point where you want to split it.
    - Alternatively, select one or more strips, place the Playhead at the time point where you want to
      split them, and press one of the keyboard shortcuts below.

    You can choose between the following split types:

    Soft `K`
    :   After splitting, it’s still possible to restore the cut content in the new strips
        by dragging their handles.

    Hard `Shift`-`K`
    :   After splitting, it’s not possible to restore the cut content by dragging handles.
        However, you can still restore it by changing the [Hold Offset](sidebar/strip.xhtml#sequencer-duration-hard)
        in the Sidebar.

Slip
:   Moves only the content of the strip. By default, the tool only allows the content to be moved within
    strip handles. If this limit applies, the strip outline is drawn in red color. By pressing `C`
    the limiting is toggled on or off.
user: Explain Displays in complete detail according to the official Blender documentation.

assistant: The color space of the display that images and video are being created for.

Regular compute displays support sRGB, and most images and videos are
stored in this color space. However moderns displays often support a wider
gamut and high dynamic range content.

Standard Dynamic Range (SDR)
:   sRGB:
    :   Basic display supported everywhere.

    Display P3:
    :   Wide gamut for Apple devices and other modern displays.

    Rec.1886:
    :   Used by many older TVs.

    Rec.2020:
    :   Even wider gamut than P3 supported by some displays.

High Dynamic Range (HDR)
:   Rec.2100 PQ:
    :   For HDR displays with Rec.2020 wide gamut, up to 10000 nits.

    Rec.2100 HLG:
    :   For HDR TVs with Rec.2020 wide gamut, up to 1000 nits.

### Wide Gamut

Select the “Display P3” or “Rec.2020” display to view wide gamut colors.

This should be used in conjunction with the “ACEScg” or “Linear Rec.2020” working space
for materials, lights, rendering and compositing.

Requirements:

- A P3 or Rec.2020 capable monitor.
- macOS: Any Apple Silicon device.
- Linux: Use Wayland, and set the Vulkan backend in the Blender system preferences.
- Windows: Enable “Automatically manage color for apps” in the Windows display settings,
  and set the Vulkan backend in the Blender system preferences.

### High Dynamic Range

Select the “Rec.2100 PQ” or “Rec.21000 HLG” display to view high dynamic range (HDR) colors.

With standard dynamic range (SDR), views must significantly lower bright colors to fit within the range.
With high dynamic range it is possible to go beyond and more accurately display the scene. HDR displays have limits
too, and there are separate views for 500, 1000, 2000 and 4000 nits to target displays with different maximum
luminance.

In Blender, HDR content automatically scales up and down along with display brightness. Seeing the full range often
requires lowering the display brightness, to make enough headroom above SDR white.

Requirements:

- A HDR capable monitor.
- macOS: Any Apple Silicon device.
- Linux: Use Wayland, and set the Vulkan backend in the Blender system preferences.
- Windows: Enable “Use HDR” in the Windows display settings, and set the Vulkan backend in the Blender system
  preferences.

### Display Emulation

Automatic:
:   Display images consistent with most other applications, to preview images and video
    for export. A best effort is made to emulate the chosen display on the actual
    display device.

Off:
:   Directly output image as produced by OpenColorIO. This is not correct in general,
    but may be used when the system configuration and actual display device is known
    to match the chosen display.

Emulation is not supported with older [OpenColorIO configurations](opencolorio.xhtml#ocio-config).
user: Describe NodeEvaluateClosureInputItems(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeEvaluateClosureInputItems(bpy_struct)

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

*class* bpy.types.NodeEvaluateClosureInputItems(*bpy_struct*)
:   new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

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

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

    *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 Using Texture Nodes: syntax, arguments, return values, common patterns.

assistant: The default Blender layout has no workspace containing the Texture Node Editor.
You need to manually open it in an [area](../../interface/window_system/areas.html) of choice.

Once the editor is open, you first need to set the empty *Texture Type* selector to *Brush*,
after which you can use the [Data-Block Menu](../../interface/controls/templates/data_block.html)
to start creating textures. Note that you need to enable *Use Nodes* in the header
before you can add nodes.