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

assistant: # TextureSlot(bpy_struct)

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

subclasses —
[`BrushTextureSlot`](bpy.types.BrushTextureSlot.html#bpy.types.BrushTextureSlot "bpy.types.BrushTextureSlot"), [`LineStyleTextureSlot`](bpy.types.LineStyleTextureSlot.html#bpy.types.LineStyleTextureSlot "bpy.types.LineStyleTextureSlot"), [`ParticleSettingsTextureSlot`](bpy.types.ParticleSettingsTextureSlot.html#bpy.types.ParticleSettingsTextureSlot "bpy.types.ParticleSettingsTextureSlot")

*class* bpy.types.TextureSlot(*bpy_struct*)
:   Texture slot defining the mapping and influence of a texture

    blend_type
    :   Mode used to apply the texture

        Type:
        :   enum in [`'MIX'`, `'DARKEN'`, `'MULTIPLY'`, `'LIGHTEN'`, `'SCREEN'`, `'ADD'`, `'OVERLAY'`, `'SOFT_LIGHT'`, `'LINEAR_LIGHT'`, `'DIFFERENCE'`, `'SUBTRACT'`, `'DIVIDE'`, `'HUE'`, `'SATURATION'`, `'COLOR'`, `'VALUE'`], default `'MIX'`

    color
    :   Default color for textures that don’t return RGB or when RGB to intensity is enabled

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, inf], default (1.0, 1.0, 1.0)

    default_value
    :   Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard

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

    name
    :   Texture slot name

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

    offset
    :   Fine tune of the texture mapping X, Y and Z locations

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

    output_node
    :   Which output node to use, for node-based textures

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

    scale
    :   Set scaling for the texture’s X, Y and Z sizes

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

    texture
    :   Texture data-block used by this texture slot

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Multi-View and Stereo 3D Image I/O and how is it used in Blender Python scripting?

assistant: Multi-View and Stereo 3D
:   Multi-view images can be saved in special formats according to the production requirements.
    By default the system saves each view as an individual file,
    thus generating as many files as views to be rendered.
    In stereo 3D productions, for the final deployment or
    even intermediary previews it is convenient to save stereo 3D images,
    that are ready to use with 3D displays or simple anaglyph glasses.
    The formats supported match the display modes available for the window.

Lossy-Formats
:   Some stereo 3D formats represent a considerable loss of data.
    For example, the Anaglyph format will cap out entire color channels from the original image.
    The Top-Bottom compressed will discard half of your vertical resolution data.
    The Interlace will mash your data considerably.
    Once you export in those formats, you can still import the image
    back in Blender, for it to be treated as Stereo 3D.
    You will need to match the window stereo 3D display mode to the image stereo 3D format though.

Lossless Formats
:   Some formats will preserve the original data,
    leading to no problems on exporting and importing the files back in Blender.
    The Individual option will produce separate images that
    (if saved in a lossless encoding such as `PNG` or `OpenEXR`)
    can be loaded back in production with no loss of data.
    For the Stereo 3D formats the only lossless options are
    *Top-Bottom* and *Side-by-Side* without the Squeezed Frame option.

Multi-View OpenEXR
:   Another option is to use multi-view OpenEXR files. This format can save multiple views in
    a single file and is backward compatible with old OpenEXR viewers (you see only one view though).
    Multi-view native support is only available to OpenEXR.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Gizmo.invoke`](bpy.types.Gizmo.html#bpy.types.Gizmo.invoke "bpy.types.Gizmo.invoke") - [`Gizmo.modal`](bpy.types.Gizmo.html#bpy.types.Gizmo.modal "bpy.types.Gizmo.modal") - [`KeyMapItems.match_event`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.match_event "bpy.types.KeyMapItems.match_event") - [`Operator.invoke`](bpy.types.Operator.html#bpy.types.Operator.invoke "bpy.types.Operator.invoke") - [`Operator.modal`](bpy.types.Operator.html#bpy.types.Operator.modal "bpy.types.Operator.modal") | - [`Window.event_simulate`](bpy.types.Window.html#bpy.types.Window.event_simulate "bpy.types.Window.event_simulate") - [`WindowManager.invoke_confirm`](bpy.types.WindowManager.html#bpy.types.WindowManager.invoke_confirm "bpy.types.WindowManager.invoke_confirm") - [`WindowManager.invoke_props_popup`](bpy.types.WindowManager.html#bpy.types.WindowManager.invoke_props_popup "bpy.types.WindowManager.invoke_props_popup") - [`WindowManager.piemenu_begin__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.piemenu_begin__internal "bpy.types.WindowManager.piemenu_begin__internal") |
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`MovieTracking.reconstruction`](bpy.types.MovieTracking.html#bpy.types.MovieTracking.reconstruction "bpy.types.MovieTracking.reconstruction") | - [`MovieTrackingObject.reconstruction`](bpy.types.MovieTrackingObject.html#bpy.types.MovieTrackingObject.reconstruction "bpy.types.MovieTrackingObject.reconstruction") |
user: Provide the full official documentation entry for Thumb, preserving all code examples.

assistant: # Thumb

Similar to the [Grab](grab.html) brush,
but instead only moves the geometry along the surface (using the area plane).
This is useful for grabbing surfaces with a very specific direction,
or without making too impactful changes to the overall object shape.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   The input geometry containing the hair curves to displace.

Factor
:   Scales the overall displacement strength.
    A value of 0.0 applies no displacement, while 1.0 applies the full displacement vector.

Shape
:   Defines how the displacement factor changes along the length of each curve.
    A value of 0.0 applies a constant displacement, while 0.5 results in a linear falloff from root to tip.

Object Space
:   The object whose transform defines the coordinate space of the displacement.
    If unset, displacement is applied in the modifier’s local space.

Displace Vector
:   The vector used to determine the direction and magnitude of the displacement.
    This can be driven by fields or other procedural inputs.

### Surface Normal

When enabled, displaces the curves along the normal of a surface, allowing for effects like
“pushing” or “lifting” hair away from a mesh.

Can be enabled from the header.

Surface Input Type
:   Determines how the surface data is provided for sampling the normals.
    The geometry input takes priority over the object input.

    Object:
    :   Use an object reference to sample surface normals.

    Geometry:
    :   Use a geometry input to sample normals directly.

Surface
:   The surface object used to sample the normals for displacement.

Surface UV Map
:   The UV map used when sampling the surface normals for displacement.

Surface Normal Displacement
:   Amount of displacement applied along the sampled surface normal.
    Can be positive or negative depending on the desired direction.
user: Give a detailed overview of GeometryNodeSampleNearest(GeometryNode): syntax, arguments, return values, common patterns.

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: What is GeometryNodeStoreNamedGrid(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeStoreNamedGrid(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.GeometryNodeStoreNamedGrid(*GeometryNode*)
:   Store grid data in a volume geometry with the specified name

    data_type
    :   Type of grid data

        Type:
        :   enum in [Volume Grid Data Type Items](bpy_types_enum_items/volume_grid_data_type_items.html#rna-enum-volume-grid-data-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: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Data Type
:   Float:
    :   The node will accumulate a *Float* field.

    Integer:
    :   The node will accumulate an *Integer* field.

    Vector:
    :   The node will accumulate a *Vector* field.

    Transform:
    :   The node will accumulate a *Matrix* field.

Domain
:   The [attribute domain](../../attributes_reference.xhtml#attribute-domains) used for accumulation
    and for evaluation of the *Value* input.
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") - [`Attribute.name`](bpy.types.Attribute.html#bpy.types.Attribute.name "bpy.types.Attribute.name") - [`Attribute.data_type`](bpy.types.Attribute.html#bpy.types.Attribute.data_type "bpy.types.Attribute.data_type") - [`Attribute.storage_type`](bpy.types.Attribute.html#bpy.types.Attribute.storage_type "bpy.types.Attribute.storage_type") | - [`Attribute.domain`](bpy.types.Attribute.html#bpy.types.Attribute.domain "bpy.types.Attribute.domain") - [`Attribute.is_internal`](bpy.types.Attribute.html#bpy.types.Attribute.is_internal "bpy.types.Attribute.is_internal") - [`Attribute.is_required`](bpy.types.Attribute.html#bpy.types.Attribute.is_required "bpy.types.Attribute.is_required") |
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: Draw a dotted line around the strokes you want to trim.
After releasing the mouse button all the points on the selected strokes
will be deleted until another intersecting stroke is found.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_cutter_example-01.png   Original drawing. | ../../../../_images/grease-pencil_modes_draw_tools_cutter_example-02.png   Lasso Selecting the strokes to be trimmed. | ../../../../_images/grease-pencil_modes_draw_tools_cutter_example-03.png   Final result. |
user: Describe Output from the Blender manual or Python API, including usage steps and snippets.

assistant: # Output

[image reference removed]

Output panel.

This panel provides options for setting the location of rendered frames for animations,
and the quality of the saved images.

File Path
:   Choose the location to save rendered frames.

    When rendering an animation,
    the frame number is appended at the end of the file name with four padded zeros (e.g. `image0001.png`).
    You can set a custom padding size by adding the appropriate number of `#` anywhere in the file name
    (e.g. `image_##_test.png` translates to `image_01_test.png`).

    This setting expands [Relative Paths](../../../files/blend/open_save.html#files-blend-relative-paths)
    where a `//` prefix represents the directory of the current blend-file.

Saving – File Extensions
:   Adds the correct file extensions per file type to the output files.

Saving – Cache Result
:   Saves the rendered view layers and their [passes](../../layers/passes.html) to a multi-layer OpenEXR image.
    The Compositor can then use this file to improve performance, especially for heavy compositing.

    The image is stored in the *Render Cache* folder as specified in the
    [File Paths Preferences](../../../editors/preferences/file_paths.html).
    You can also load it back into the Image Editor’s Render Result, even after closing
    and reopening Blender; see [Open Cached Render](../../../editors/image/editing.html#bpy-ops-image-read-viewlayers).

Media Type
:   The type of media to save.

    Image:
    :   Saves each input as a separate image file.
        Each input can use its own image format settings.

    Multi-Layer EXR:
    :   Saves all inputs together in a single multi-layer OpenEXR file.

    Video:
    :   Encodes each frame into a video container.
        Encoding options can be found in the [Encoding](#encoding) panel.

File Format Image
:   Choose the image file format to save to. Based on which format is used,
    other options such as channels, bit depth and compression level are available.
    See [saving images](../../../files/media/image_formats.html#bpy-types-imageformatsettings) for list of image encoding options.

Color Image Multi-Layer EXR
:   The color format to save the image or video to.
    This setting is used by some formats to optimize how much data is written to the file.
    Note, *RGBA* is not available for all image formats, check the list above for details.

    BW:
    :   Saves the image using grayscale colors.

    RGB:
    :   Saves red, green and blue channels

    RGBA:
    :   Saves red, green, blue and alpha channels.

Image Sequence – Overwrite Image Multi-Layer EXR
:   Overwrite existing files when rendering.

Image Sequence – Overwrite Image Multi-Layer EXR
:   Create empty placeholder frames while rendering.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Points
:   The Point Cloud geometry component.

Curve Group ID
:   All points with the same Group ID value will be joined in the same curve.
    The value of Group ID can be any value (negative, zero, or infinity, etc.).
    All created curves must have at least a single point.
    The order of curves depends both on Group ID value and on the order of Group ID values in the Point Cloud.

Weight
:   If the curve contains more than one Point, the Weight of each Point is used to define the
    order of all points in curve via sorting. The goal of sorting is to have points with the minimal
    Weight value at the start of curve and the maximum Weight at the end of curve.
user: Provide the full official documentation entry for Points, preserving all code examples.

assistant: The main element used in editing Grease Pencil objects are points.
Points represent a single point in 3D space.

Each point stores all the properties that define the final appearance of the strokes
as its location, thickness, alpha, weight and UV rotation for textures.
user: How do I use CompositorNodeSwitch(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeSwitch(CompositorNode)

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

*class* bpy.types.CompositorNodeSwitch(*CompositorNode*)
:   Switch between two images using a checkbox

    *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")

    update()

    *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 RepeatItem(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # RepeatItem(bpy_struct)

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

*class* bpy.types.RepeatItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

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

    socket_type
    :   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), default `'FLOAT'`

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Creates a suitable breakdown pose on the current frame.

The Breakdowner tool can be constrained to work on specific transforms and axes,
by pressing the following keys while the tool is active:

- `G`, `R`, `S`: move, rotate, scale
- `B`: Bendy bones
- `C`: custom properties
- `X`, `Y`, `Z`: to the corresponding axes
user: Describe GeometryNodeInputObject(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeInputObject(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.GeometryNodeInputObject(*GeometryNode*)
:   Output a single object

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

    *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 View from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Display

You can set the editor’s display options in this panel.

[image reference removed]

Display panel.

Aspect Ratio
:   Display aspect for this image. Does not affect rendering.

Repeat Image
:   Tile the image so it completely fills the editor.

### Annotations

Options for the annotation tool. See [Annotations](../../interface/annotate_tool.xhtml).
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: ### Traditional Animation

This example shows you how to animate a bouncing ball
with a traditional 2D animation technique and Grease Pencil.

First, go to menu File ‣ New ‣ 2D Animation to start with a new 2D animation template.
The template is ready to quick start your animation with a Grease Pencil object already created,
Onion Skinning activated, Auto Keyframe enabled and in camera view.

1. Set the range of the animation in the Timeline from 1 to 24.
2. In the 3D Viewport draw a ball on the upper left corner with the Draw Tool (extreme).
3. Move to frame 12 and draw a squashed ball in the bottom center (breakdown).
4. Move to frame 24 and draw a ball in the top right corner of the 3D Viewport (extreme).
5. Keep drawing all the in-between frames you want using the onion skinning ghost as a reference.

To test the animation, press `Spacebar` to play.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`BlendData.palettes`](bpy.types.BlendData.html#bpy.types.BlendData.palettes "bpy.types.BlendData.palettes") - [`BlendDataPalettes.new`](bpy.types.BlendDataPalettes.html#bpy.types.BlendDataPalettes.new "bpy.types.BlendDataPalettes.new") | - [`BlendDataPalettes.remove`](bpy.types.BlendDataPalettes.html#bpy.types.BlendDataPalettes.remove "bpy.types.BlendDataPalettes.remove") - [`Paint.palette`](bpy.types.Paint.html#bpy.types.Paint.palette "bpy.types.Paint.palette") |
user: Explain Limit Distance Constraint in complete detail according to the official Blender documentation.

assistant: # Limit Distance Constraint

The *Limit Distance* constraint forces an object or bone to stay further from,
nearer to, or exactly at a given distance from a target. In other words,
the owner’s location is constrained to be either outside, inside,
or on the surface of a sphere centered on the target.
user: How do I use Index Switch Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Index Switch Node

[image reference removed]

The *Index Switch* node outputs one of its inputs based on an integer *Index* value.
Only the selected input is evaluated, making this node useful for switching between
multiple data inputs efficiently.
user: What is Simple Object Panel and how is it used in Blender Python scripting?

assistant: This panel has a [`Panel.poll`](#bpy.types.Panel.poll "bpy.types.Panel.poll") and [`Panel.draw_header`](#bpy.types.Panel.draw_header "bpy.types.Panel.draw_header") function,
even though the contents is basic this closely resembles blenders panels.

```
import bpy

class ObjectSelectPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_select"
    bl_label = "Select"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"
    bl_options = {'DEFAULT_CLOSED'}

    @classmethod
    def poll(cls, context):
        return (context.object is not None)

    def draw_header(self, context):
        layout = self.layout
        layout.label(text="My Select Panel")

    def draw(self, context):
        layout = self.layout

        box = layout.box()
        box.label(text="Selection Tools")
        box.operator("object.select_all").action = 'TOGGLE'
        row = box.row()
        row.operator("object.select_all").action = 'INVERT'
        row.operator("object.select_random")

bpy.utils.register_class(ObjectSelectPanel)
```
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/compositing_types_color_depth-combine_example-1.png)

Choosing closest pixels.

In the example above, the render output from two scenes are mixed using the Depth Combine node,
one from a sphere of size 1.3, and the other a cube of size 1.0.
The sphere and square are located at the same place. The cube is tipped forward,
so the corner in the center is closer to the camera than the sphere surface;
so Depth Combine chooses to use the cube’s pixels. But the sphere is slightly larger
(a size of 1.3 versus 1.0), so it does not fit totally inside the cube. At some point,
as the cube’s sides recede back away from the camera, the sphere’s sides are closer.
When this happens, Depth Combine uses the sphere’s pixels to form the resulting picture.

This node can be used to combine a foreground with a background matte painting.
Walt Disney pioneered the use of multi-plane mattes, where three or four partial mattes were
painted on glass and placed on the left and right at different depth positions; minimal camera
moves to the right created the illusion of depth as Bambi moved through the forest.

[[image reference removed]](../../../_images/compositing_types_color_depth-combine_example-2.png)

Mix and match images.

The Depth Combine can be used to merge two images as well.
Using the depth values from the sphere and cube scenes above, but inputting different images,
yields the example to the right.

[[image reference removed]](../../../_images/compositing_types_color_depth-combine_example-3.png)

Depth Combine in action.

In this node setup a render scene is mixed with a flat image. In the side view of the scene,
the orange cube is 10 units away from the camera, and the blue ball is at a depth of 20.
The 3D cursor is about 15 units away from the camera.
The image depth is 15, thus inserting it in between the cube and the ball.
The resulting image appears to have the cube on the green image.
user: Describe Explode Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Explode Modifier

The *Explode* modifier is used to alter the mesh geometry by moving/rotating its faces in a way
that roughly tracks particles emitted by that object, making it look as if the mesh is being exploded
(broken apart and pushed outward).

For this modifier to have any visible effect, there needs to be a particle system on its object.
That particle system will control how the mesh is exploded.

Both the number of emitted particles and number of faces determine how granular the *Explode* modifier is.
More of each faces and particles will mean more individual pieces.

Here is a
[demo video](https://archive.blender.org/wiki/2015/index.php/File:Manual_-_Explode_Modifier_-_Exploding_Cube_-_2.5.ogg/)
showing a cube with a particle system and *Explode* modifier.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Manual_-_Explode_Modifier_-_Exploding_Cube_-_2.5.blend)).
user: Describe Shape from the Blender manual or Python API, including usage steps and snippets.

assistant: # Shape

These settings control the shape of hair curves for rendering.

Strand Shape
:   A shape parameter that controls the transition in thickness between the root and tip.
    Negative values make the primitive rounded more towards the top,
    the value of zero makes the primitive linear,
    and positive values make the primitive rounded more towards the bottom.

Diameter Root
:   Multiplier of the hair width at the root.

Tip
:   Multiplier of the hair width at the tip.

Radius Scale
:   Multiplier for the *Root* and *Tip* values. This can be used to change the thickness of the hair.

Close Tip
:   Sets the thickness at the tip to zero, even when using a nonzero tip multiplier.
user: Give a detailed overview of Mouse Position Node: syntax, arguments, return values, common patterns.

assistant: # Mouse Position Node

[image reference removed]

The *Mouse Position* node returns information about the mouse cursor
such as its position and the [region’s](../../../../interface/window_system/regions.html) dimensions.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Properties are available in the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Locks the current item list and types to stabilize interfaces when publishing node groups.
    When enabled, adding/removing items is disabled until the option is turned off.

### Bundle Items

List of bundle items
:   Displays one entry per element in the bundle.
    Double-click to rename.

    Add Item
    :   Add a new socket to the bundle.

    Remove Item
    :   Delete the selected socket.

Type
:   The data type for the selected item (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control is shown and used when the socket is unlinked.
user: Describe Edit Group from the Blender manual or Python API, including usage steps and snippets.

assistant: With a node group selected, press `Tab` to move into it and see its content.
Press `Tab` again (or `Ctrl`-`Tab`) to leave the group and go back to
its parent, which could be the top-level node tree or another node group.
You can refer to the breadcrumbs in the top left corner of the node editor
to see where you are in the hierarchy.

[image reference removed]

Example of an expanded node group.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.curve`](bpy.context.html#bpy.context.curve "bpy.context.curve") - [`BlendData.curves`](bpy.types.BlendData.html#bpy.types.BlendData.curves "bpy.types.BlendData.curves") - [`BlendDataCurves.new`](bpy.types.BlendDataCurves.html#bpy.types.BlendDataCurves.new "bpy.types.BlendDataCurves.new") | - [`BlendDataCurves.remove`](bpy.types.BlendDataCurves.html#bpy.types.BlendDataCurves.remove "bpy.types.BlendDataCurves.remove") - [`Object.to_curve`](bpy.types.Object.html#bpy.types.Object.to_curve "bpy.types.Object.to_curve") |
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`Annotation.layers`](bpy.types.Annotation.html#bpy.types.Annotation.layers "bpy.types.Annotation.layers") - [`AnnotationLayers.new`](bpy.types.AnnotationLayers.html#bpy.types.AnnotationLayers.new "bpy.types.AnnotationLayers.new") | - [`AnnotationLayers.remove`](bpy.types.AnnotationLayers.html#bpy.types.AnnotationLayers.remove "bpy.types.AnnotationLayers.remove") |
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Angle
:   The amount of rotation.

Axis
:   Used to constraint the transformation to one or more axes.

Orientation
:   Aligns the transformation axes to a specified orientation constraint.
    See [Transform Orientations](../../../../editors/3dview/controls/orientation.xhtml) for more information.

Proportional Editing
:   The extruded face will affect nearby geometry.
    See [Proportional Editing](../../../../editors/3dview/controls/proportional_editing.xhtml) for a full reference.
user: What is basic.super_copy and how is it used in Blender Python scripting?

assistant: Single-bone rig type that simply copies the bone. Useful as utility rig type for
adding custom features or specific deform bones to your rigs.

Control (Boolean)
:   When enabled a control bone and widget will be created.

Widget (Boolean)
:   When enabled a widget will be created in replacement to the standard.

Widget Type (String):
:   Allows selecting one of the predefined widget types to generate instead of the default circle.

Deform (Boolean)
:   When enabled a deform bone will be created.

Relink Constraints
:   Works the same as in the [basic.raw_copy](#basic-raw-copy) rig. In addition, when enabled any constraints that have
    names prefixed with `CTRL:` are moved to the control, and with `DEF:` to the deform bone.
user: How do I use Volumetric Data in Blender? Include parameters, examples, warnings and best practices.

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

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

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

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

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

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

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

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

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

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

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

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

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

Export Mantaflow Script
:   Export the simulation as a standalone Mantaflow script when baking the scene (exported on “Bake Data”).
    Usually, only developers and advanced users who know how to use the Mantaflow GUI will
    make use of this functionality. Use a [Debug Value](../../../../advanced/operators.html#bpy-ops-wm-debug-menu) of `3001` to enable.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Properties should be documented using definition lists. Properties that are hidden based on other properties should
used nested definitions:

```
Property
   Property description.

   Hidden Property
      Hidden property description.
```

Select menus should be documented using the following syntax:

```
Menu Label
   General description of the menu.

   :Menu Item: Menu Item Definition.
   :Menu Item: Menu Item Definition.
   :Menu Item: Menu Item Definition.
```
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

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

assistant: # Node Map Range Items

LINEAR:
:   Linear.

    Linear interpolation between From Min and From Max values.

STEPPED:
:   Stepped Linear.

    Stepped linear interpolation between From Min and From Max values.

SMOOTHSTEP:
:   Smooth Step.

    Smooth Hermite edge interpolation between From Min and From Max values.

SMOOTHERSTEP:
:   Smoother Step.

    Smoother Hermite edge interpolation between From Min and From Max values.
user: Give a detailed overview of Prefetch: syntax, arguments, return values, common patterns.

assistant: Fills cache with frames. As many frames as fits into cache are load form the drive.
This allows to fill in the cache as fast as possible when you really need to track something,
but this keeps CPU and drive bandwidth idle if you’ve got a Clip editor opened but not actually interacting with it.
user: Give a detailed overview of NodeTreeInterfaceSocketVectorAcceleration4D(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

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

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: This rig extends the basic chain with automation that propagates movement of the start and end,
and an optional middle control, to other controls. This results in stretching the whole chain
when moving one of the ends, rather than just the immediately adjacent B-Bones.

Middle Control Position
:   Specifies the position of the middle control within the chain; disabled when zero.

Falloff
:   Specifies the influence falloff curves of the start, middle and end controls.
    Zero results in linear falloff, increasing widens the influence, and -10 disables
    the influence propagation from that control completely.

Spherical Falloff
:   Toggle buttons to change the shape of the falloff curve from a power curve that at falloff 1 forms a parabola
    \(1 - x^{2^f}\) to a curve forming a circle \((1 - x^{2^f})^{2^{-f}}\).

Falloff Along Chain Curve
:   Computes the falloff curve along the length of the chain, instead of projecting on the straight
    line connecting its start and end points.

Propagate Twist
:   Specifies whether twist of the chain should be propagated to control points between main controls.

Propagate Scale
:   Specifies whether perpendicular scaling of the chain should be propagated to control points between main controls.

Propagate to Controls
:   Allows other chains to see propagated twist and scale via *Merge Parent Rotation and Scale* when their
    controls are merged into this chain, instead of it being completely local to this chain.

Primary Control Layers
:   Optionally specifies bone collections for the end controls.

Secondary Control Layers
:   Optionally specifies bone collections for the middle control, falling back to *Primary Control Layers* if not set.

The main controls with active falloff have the effect of *Merge Parent Rotation and Scale*
automatically enabled just for them.
user: What is limbs.leg and how is it used in Blender Python scripting?

assistant: Will create a fully featured bendy and stretchy leg depending on the user-defined options.

Requirement: A chain of four connected bones (thigh, shin, foot, toe) with one unconnected
child of the foot to be used as the heel pivot.

[image reference removed]

Leg required bones.

Foot Pivot (Ankle, Toe, Ankle & Toe)
:   Specifies where to put the pivot location of the main IK control, or whether to generate an additional
    pivot control at the base of the toe.

Separate IK Toe
:   Specifies that two separate toe controls should be generated for IK and FK instead of sharing one bone.
    This is necessary to get fully correct IK-FK snapping in all possible poses.

Toe Tip Roll
:   Generates a slider to switch the heel control to pivot on the tip rather than the base of the toe
    (for roll this obviously only applies on forward roll).

Rotation Axis (Automatic, X, Z)
:   Defines the bend axis for the IK chain. FK chains will have a totally free degree of rotation on all axes.

Limb Segments (integer)
:   Defines the number of additional tweak controls each limb bone will have on the final rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Custom IK Pivot
:   Generates an extra control for the end of the IK limb that allows rotating it around an arbitrarily placed pivot.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.