PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of NDOFMotionEventData(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NDOFMotionEventData(bpy_struct)

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

*class* bpy.types.NDOFMotionEventData(*bpy_struct*)
:   NDOF motion data for window manager events

    progress
    :   Indicates the gesture phase

        Type:
        :   enum in [`'STARTING'`, `'IN_PROGRESS'`, `'FINISHING'`], default `'STARTING'`, (readonly)

    rotation
    :   Axis-angle rotation of this motion event. The vector magnitude is the angle where 1.0 represents 360 degrees. The angle is typically scaled by the time-delta before use.

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

    time_delta
    :   Time since previous motion event (in seconds)

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    translation
    :   The translation of this motion event. The range on each axis is [-1 to 1], before being multiplied by the sensitivity preference. This is typically scaled by the time-delta before use.

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: - OpenVDB excels at representing sparse volumes, that aren’t necessarily
  concentrated within a tight bounding box but may be spread out through space.
  However, in Blender, these are still rendered as dense volumes
  which is not ideal for performance and memory usage. This will be improved in future releases.
- OpenVDB files can also store level sets and points.
  While level set grids can be read, there is no current support for rendering them as surfaces.
  Importing OpenVDB points is not supported.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: R
:   The radial distance from the origin in the X-Y plane.

Phi
:   The angular position around the Z axis.

Z
:   The vertical component of the input vector, corresponding directly to its Z coordinate.
user: Explain SoundEqualizerModifier(StripModifier) in complete detail according to the official Blender documentation.

assistant: # SoundEqualizerModifier(StripModifier)

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

*class* bpy.types.SoundEqualizerModifier(*StripModifier*)
:   Equalize audio

    graphics
    :   Graphical definition equalization

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

    new_graphic(*min_freq*, *max_freq*)
    :   Add a new EQ band

        Parameters:
        :   - **min_freq** (*float in* *[**0**,* *20000**]*) – Minimum Frequency, Minimum Frequency
            - **max_freq** (*float in* *[**0**,* *20000**]*) – Maximum Frequency, Maximum Frequency

        Returns:
        :   Newly created graphical Equalizer definition

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

    clear_soundeqs()
    :   Remove all graphical equalizers from the Equalizer modifier

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

assistant: # Symmetrize

The *Symmetrize* tool is a quick way to make a mesh symmetrical.
*Symmetrize* works by cutting the mesh at the pivot point of the object,
and mirroring over the geometry in the specified axis, and merges the two halves together
(if they are connected). Also the mesh data is copied from one side to the other:
e.g. UVs, colors attributes, vertex weights.

Direction
:   Specify the axis and direction of the effect. Can be any of the three axes,
    and either positive to negative, or negative to positive.

Threshold
:   The vertices in this range will be snapped to the plane of symmetry.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_symmetrize_example-1.png>   Mesh before Symmetrize. | <../../../../_images/modeling_meshes_editing_mesh_symmetrize_example-2.png>   Mesh after Symmetrize. |
user: Give a detailed overview of Debug: syntax, arguments, return values, common patterns.

assistant: Undo Legacy
:   Use legacy undo (slower than the new default one, but may be more stable in some cases).

No Override Auto Resync
:   Disables library overrides automatic resync detection and process on file load.
    Enable when dealing with older blend-files that need manual Resync (Enforce) handling.

Cycles Debug
:   Show the Cycles rendering debug panel.

Asset Debug Info
:   Enable some extra fields in the Asset Browser to aid debugging.

Asset Indexing
:   Disabling the asset indexer forces every asset library refresh to completely reread assets from disk.

Viewport Debug
:   Enable viewport debugging options for developers in the overlays pop-over.

EEVEE Debug
:   Enable EEVEE debugging options for developers.
user: What is NodeReroute(NodeInternal) and how is it used in Blender Python scripting?

assistant: # NodeReroute(NodeInternal)

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

*class* bpy.types.NodeReroute(*NodeInternal*)
:   A single-socket organization tool that supports one input and multiple outputs

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use gpu_extras submodule (gpu_extras.presets) in Blender? Include parameters, examples, warnings and best practices.

assistant: # gpu_extras submodule (gpu_extras.presets)

gpu_extras.presets.draw_circle_2d(*position*, *color*, *radius*, *\**, *segments=None*)
:   Draw a circle.

    Parameters:
    :   - **position** (*Sequence**[**float**]*) – 2D position where the circle will be drawn.
        - **color** (*Sequence**[**float**]*) – Color of the circle (RGBA).
          To use transparency blend must be set to `ALPHA`, see: [`gpu.state.blend_set()`](gpu.state.html#gpu.state.blend_set "gpu.state.blend_set").
        - **radius** (*float*) – Radius of the circle.
        - **segments** (*int* *|* *None*) – How many segments will be used to draw the circle.
          Higher values give better results but the drawing will take longer.
          If None or not specified, an automatic value will be calculated.

gpu_extras.presets.draw_texture_2d(*texture*, *position*, *width*, *height*, *is_scene_linear_with_rec709_srgb_target=False*)
:   Draw a 2d texture.

    Parameters:
    :   - **texture** ([`gpu.types.GPUTexture`](gpu.types.html#gpu.types.GPUTexture "gpu.types.GPUTexture")) – GPUTexture to draw (e.g. gpu.texture.from_image(image) for [`bpy.types.Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image")).
        - **position** (*2D Vector*) – Position of the lower left corner.
        - **width** (*float*) – Width of the image when drawn (not necessarily
          the original width of the texture).
        - **height** (*float*) – Height of the image when drawn.
        - **is_scene_linear_with_rec709_srgb_target** (*bool*) – True if the texture is stored in scene linear color space and
          the destination framebuffer uses the Rec.709 sRGB color space
          (which is true when drawing textures acquired from [`bpy.types.Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image") inside a
          ‘PRE_VIEW’, ‘POST_VIEW’ or ‘POST_PIXEL’ draw handler).
          Otherwise the color space is assumed to match the one of the framebuffer. (default=False)
user: How do I use FunctionNodeAxesToRotation(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeAxesToRotation(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.FunctionNodeAxesToRotation(*FunctionNode*)
:   Create a rotation from a primary and (ideally orthogonal) secondary axis

    primary_axis
    :   Axis that is aligned exactly to the provided primary direction

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

    secondary_axis
    :   Axis that is aligned as well as possible given the alignment of the primary axis

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain VolumeDisplay(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # VolumeDisplay(bpy_struct)

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

*class* bpy.types.VolumeDisplay(*bpy_struct*)
:   Volume object display settings for 3D viewport

    density
    :   Thickness of volume display in the viewport

        Type:
        :   float in [1e-05, inf], default 0.0

    interpolation_method
    :   Interpolation method to use for volumes in solid mode

        - `LINEAR`
          Linear – Good smoothness and speed.
        - `CUBIC`
          Cubic – Smoothed high quality interpolation, but slower.
        - `CLOSEST`
          Closest – No interpolation.

        Type:
        :   enum in [`'LINEAR'`, `'CUBIC'`, `'CLOSEST'`], default `'LINEAR'`

    slice_axis
    :   - `AUTO`
          Auto – Adjust slice direction according to the view direction.
        - `X`
          X – Slice along the X axis.
        - `Y`
          Y – Slice along the Y axis.
        - `Z`
          Z – Slice along the Z axis.

        Type:
        :   enum in [`'AUTO'`, `'X'`, `'Y'`, `'Z'`], default `'AUTO'`

    slice_depth
    :   Position of the slice

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

    use_slice
    :   Perform a single slice of the domain object

        Type:
        :   boolean, default False

    wireframe_detail
    :   Amount of detail for wireframe display

        - `COARSE`
          Coarse – Display one box or point for each intermediate tree node.
        - `FINE`
          Fine – Display box for each leaf node containing 8×8 voxels.

        Type:
        :   enum in [`'COARSE'`, `'FINE'`], default `'COARSE'`

    wireframe_type
    :   Type of wireframe display

        - `NONE`
          None – Don’t display volume in wireframe mode.
        - `BOUNDS`
          Bounds – Display single bounding box for the entire grid.
        - `BOXES`
          Boxes – Display bounding boxes for nodes in the volume tree.
        - `POINTS`
          Points – Display points for nodes in the volume tree.

        Type:
        :   enum in [`'NONE'`, `'BOUNDS'`, `'BOXES'`, `'POINTS'`], default `'NONE'`

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

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

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

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

        Returns:
        :   The class or default when not found.

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

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

Surface Input Type
:   Determines how the surface data is provided for interpolation.

    Object:
    :   Use an object reference to provide the surface.

    Geometry:
    :   Use a geometry input directly connected to the surface mesh.

Surface
:   The surface object used as the attachment base for the interpolated curves.
    Its transforms must match those of the modifier object.

Surface UV Map
:   The UV map used to find attachment locations for the interpolated curves on the surface.

Surface Rest Position
:   When enabled, sets the surface mesh to its rest position before attaching curves.
    This ensures consistent root positions when deformation is applied afterward.

Follow Surface Normal
:   When enabled, aligns the interpolated curves with the surface normal at their root attachment point.

Part by Mesh Islands
:   When enabled, treats separate mesh islands on the surface as independent regions for interpolation,
    preventing cross-blending of guides between disconnected areas.

Interpolation Guides
:   The number of nearest guide curves used to interpolate the shape of each new curve.
    Higher values result in smoother transitions but may slightly reduce performance.

Distance to Guides
:   The maximum distance from a guide curve within which interpolation occurs.
    Curves outside this range will not influence the result.

### Distribution

Distribution Method
:   Determines how root points for interpolated curves are distributed across the surface.

    Random:
    :   Distributes roots randomly across the surface.

    Poisson Disk:
    :   Uses Poisson disk sampling to maintain a minimum distance between root points,
        producing an even and natural distribution.

Density
:   The number of interpolated hair curves generated per unit of surface area.
    Higher values increase the total hair density.

Density Mask
:   A scalar factor used to locally scale the curve density across the surface.

Mask Texture
:   Uses an image texture to control which areas of the surface generate hair.
    The image is sampled using the *Surface UV Map* input.

Viewport Amount
:   A factor used to reduce curve density in the viewport for performance optimization.
    This does not affect the final render density.

Seed
:   Sets the random seed for the interpolation and distribution processes.
    Changing this value generates a different random distribution while maintaining the same parameters.
user: Describe Texture Preview from the Blender manual or Python API, including usage steps and snippets.

assistant: If your texture is already used to color, bump map, displace, alpha-transparent, etc.,
a surface of a model in your scene (in other technical words,
is mapped to some aspect of a texture via a texture channel using UV as a map input),
you can see the effects of your painting in the context of your scene as you paint.

To do this, set up side-by-side areas, one Area in 3D Viewport set to *Texture* shading option,
and in the second Area the Image Editor loaded with your image.
Position the 3D Viewport to show the object that is UV-mapped to the loaded image.
In the image to the right, the texture being painted is mapped to the “Normal” attribute,
and is called “bump mapping”, where the grayscale image is used to make the flat surface appear bumpy.
See Texture Mapping Output for more information on bump mapping.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Lightgroups.add`](bpy.types.Lightgroups.html#bpy.types.Lightgroups.add "bpy.types.Lightgroups.add") - [`Lightgroups.remove`](bpy.types.Lightgroups.html#bpy.types.Lightgroups.remove "bpy.types.Lightgroups.remove") | - [`ViewLayer.active_lightgroup`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.active_lightgroup "bpy.types.ViewLayer.active_lightgroup") - [`ViewLayer.lightgroups`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.lightgroups "bpy.types.ViewLayer.lightgroups") |
user: Show practical ways to work with H in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**HDRI**](glossary/index.xhtml#term-HDRI) - [**Head**](glossary/index.xhtml#term-Head) | - [**High Dynamic Range Image**](glossary/index.xhtml#term-High-Dynamic-Range-Image) - [**Hue**](glossary/index.xhtml#term-Hue) |
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`NodeTreeInterface.move_to_parent`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.move_to_parent "bpy.types.NodeTreeInterface.move_to_parent") - [`NodeTreeInterface.new_panel`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.new_panel "bpy.types.NodeTreeInterface.new_panel") | - [`NodeTreeInterface.new_socket`](bpy.types.NodeTreeInterface.html#bpy.types.NodeTreeInterface.new_socket "bpy.types.NodeTreeInterface.new_socket") - [`NodeTreeInterfaceItem.parent`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.parent "bpy.types.NodeTreeInterfaceItem.parent") |
user: Explain FunctionNodeTransposeMatrix(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeTransposeMatrix(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.FunctionNodeTransposeMatrix(*FunctionNode*)
:   Flip a matrix over its diagonal, turning columns into rows and vice-versa

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

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

bpy.context.selected_ids
:   Type:
    :   sequence of [`bpy.types.ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")
user: Provide the full official documentation entry for Offset Edge Slide, preserving all code examples.

assistant: # Offset Edge Slide

Add two edge loops on either side of selected loops.

Cap Endpoint
:   Extends the loop by creating triangles at endpoints.

Factor
:   Location of the loop relative to the center loop and the outside edge loops.

Even
:   Only available for single edge loops.
    This matches the shape of the edge loop to one of the adjacent edge loops.
    (See [Edge Slide tool](edge_slide.html#modeling-meshes-editing-edge-slide) for details.)

Flipped
:   When Even is enabled, this flips the target edge loop to match.
    (See [Edge Slide tool](edge_slide.html#modeling-meshes-editing-edge-slide) for details.)

Clamp
:   Clamp within the edge extents.

Correct UVs
:   Correct UV coordinates when transforming.
user: Show practical ways to work with Header in a Blender add-on or script – include code.

assistant: Type
:   Strip type, represented by an icon.

Name
:   A text field to adjust the name of the strip, which is shown on the strip in the timeline.

    Color Tag
    :   Strips are given a [Default Color](../../../../video_editing/edit/montage/strips/introduction.xhtml#sequencer-strip-colors) based on their type;
        using the color tag, you can assign a custom color to help organize your sequence.

Mute
:   Uncheck to prevent the strip from producing output.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Data Type
:   Map Range supports both Float and Vector data types. Changing the data type will
    also update the sockets to reflect the data type chosen.

Interpolation Type
:   The mathematical method used to transition between gaps in the numerical inputs.

    Linear:
    :   Linear interpolation between From Min and From Max values.

    Stepped Linear:
    :   Stepped linear interpolation between From Min and From Max values.

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

    Smoother Step:
    :   Smoother Hermite edge interpolation between From Min and From Max values.

Clamp
:   If enabled, the output is clamped to the target range.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Image data-block used as the image source.
    Additional settings can be found in Sidebar ‣ Item ‣ Properties:
    These include options to control the alpha channel along with addition options for the color space.
    These addition options are documented with the rest of
    [Common Image Settings](../../../editors/image/image_settings.xhtml#editors-image-image-settings-common).

Color Space
:   Type of data that the image contains, either Color or Non-Color Data.
    For most color textures the default of Color should be used, but in case of e.g. a bump or alpha map,
    the pixel values should be interpreted as Non-Color Data, to avoid doing any unwanted color space conversions.

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

Texture Interpolation
:   Interpolation method used for the environment texture. The following interpolations are available:

    Linear:
    :   Regular quality interpolation.

    Closest:
    :   No interpolation, use closest pixel.

    Cubic:
    :   Smoother, better quality interpolation.

    Smart:
    :   Bicubic when magnifying, otherwise Bilinear is used.
        This is only available for [OSL](../../cycles/osl/index.xhtml).

Projection Method
:   Allows you to use different types of environmental maps. The following methods are supported:

    Equirectangular:
    :   Projection from an Equirectangular photo.

    Mirror Ball:
    :   Projection from an orthographic photo or mirror ball.
user: How do I use Creating a Soft Body in Blender? Include parameters, examples, warnings and best practices.

assistant: Soft body simulation works for all objects that have vertices or control points
(meshes, curves, surfaces, and lattices).

To add a soft body simulation to an object,
go to the *Physics* tab in the Properties and activate the *Soft Body* button.
For a reference of all the settings see [this page](settings/index.xhtml).

You start a soft body simulation by playback animation with `Alt`-`A`,
and stop the simulation with `Esc` or `Alt`-`A`.
user: Explain Format Options in complete detail according to the official Blender documentation.

assistant: `-F`, `--render-format` `<format>`
:   Set the render format.
    Valid options are:
    `TGA` `RAWTGA` `JPEG` `IRIS` `PNG` `BMP` `HDR` `TIFF`.

    Formats that can be compiled into Blender, not available on all systems:
    `OPEN_EXR` `OPEN_EXR_MULTILAYER` `FFMPEG` `CINEON` `DPX` `JP2` `WEBP`.

`-x`, `--use-extension` `<bool>`
:   Set option to add the file extension to the end of the file.
user: What is Main Region and how is it used in Blender Python scripting?

assistant: The curve view allows you to view and edit [F-Curves](fcurves/introduction.xhtml).
An F-Curve has several key parts:

Curve
:   The curve describes how the value of a property (Y axis) evolves over time (X axis).

[Keyframes](../../animation/keyframes/index.xhtml)
:   Keyframes are user-defined values on certain frames and are represented
    by little black discs that become orange when selected.
    The values on the other frames are calculated automatically by interpolating
    between these keyframes.

[Handles](fcurves/properties.xhtml#editors-graph-fcurves-settings-handles)
:   Each keyframe has two handles – points that can be dragged around to influence
    the shape of the curve around it.

[image reference removed]

A simple curve. The discs are keyframes, and the circles are their handles.

### Navigation

As with most editors, you can:

Pan
:   Pan the view by dragging with `MMB`.

Zoom
:   Zoom in and out with the mouse `Wheel`.

Scale View
:   Scale the view horizontally or vertically by dragging with `Ctrl`-`MMB`.

You can also use the scrollbars.

### Playhead & 2D Cursor

[image reference removed]

Graph Editor 2D Cursor.

The current frame is represented by a vertical blue line called the *Playhead*.
Like other [Animation Editors](../../animation/animation_editors.xhtml),
you can move it by clicking or dragging with `LMB` in the scrubbing area at the top.

Combined with the horizontal blue line, the Playhead forms the *2D Cursor*
which can be used as a [pivot point](../3dview/controls/pivot_point/index.xhtml)
for rotating and scaling. You can disable the horizontal line using
View ‣ Show Cursor or Sidebar ‣ View ‣ Show Cursor.

The 2D Cursor can be moved by clicking or dragging with `Shift`-`RMB`
or by adjusting its coordinates in the [View tab](#graph-editor-view-properties) of the Sidebar.
user: Show practical ways to work with Sample Grid Index Node in a Blender add-on or script – include code.

assistant: # Sample Grid Index Node

[image reference removed]

The *Sample Grid Index* node retrieves values directly from a voxel grid at
specific voxel indices rather than at arbitrary spatial positions.
Unlike the [Sample Grid](sample_grid.xhtml)
node, which interpolates between voxels in object space, this node reads the
exact stored value of the voxel located at the specified integer coordinates.

This makes it useful for working in *index space*, for example when performing
voxel neighborhood lookups, procedural filtering, or sampling based on values
from the [Voxel Index](../read/voxel_index.xhtml) node.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Speed Control
:   The method used to adjust the speed of the strip.

    Stretch:
    :   Automatically calculates the speed effect based on the length of the input strip.
        If you scale a strip to 1/2 the original size the sequence will play back at 2 times the speed.

    Multiply:
    :   Multiplies the current speed of the sequence by a *Multiply Factor*.
        Thus a value of 0.5 will make the sequence half as fast while 2 would make the sequence twice as fast.
        Negative values will reverse the input while also adjusting the speed,
        so a value of negative two will play in reverse and twice as fast as normal.

    Frame Number:
    :   Specifies a frame to remap the current frame to,
        for example, setting the *Frame Number* value to 50 displays the 50th frame.
        This can then be manually [keyframed](../../../../../animation/keyframes/index.html) to recreate the animation.

    Length:
    :   Maps the frame range on a percentage scale. For example, using this and a value of 50%
        will select the frame halfway through the sequence.

Interpolation
:   Crossfades between frames to reduce screen tearing when the speed is slower than the original frame rate.
user: Describe Particle Edit Disconnected Hair Brush Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Particle Edit Disconnected Hair Brush Items

COMB:
:   Comb.

    Comb hairs.

SMOOTH:
:   Smooth.

    Smooth hairs.

LENGTH:
:   Length.

    Make hairs longer or shorter.

CUT:
:   Cut.

    Cut hairs.

WEIGHT:
:   Weight.

    Weight hair particles.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Color
:   Gives the color of the smoke inside the [Fluid Domain](../../../physics/fluid/type/domain/index.xhtml).
    The color and vector outputs are the same. The Factor output is an average of the channels.

Density
:   Gives a scalar defining the density of any smoke inside
    the [Fluid Domain](../../../physics/fluid/type/domain/index.xhtml).

Flame
:   Gives a scalar defining the density of any fire inside
    the [Fluid Domain](../../../physics/fluid/type/domain/index.xhtml).
    All three outputs are the same.

Temperature
:   Gives a scalar defining the temperature of the volume. Values in the range 0 - 1 map to 0 - 1000 kelvin.
    This may be used to render physically-based fire with the Blackbody or Principled Volume shaders.
    All three outputs are the same.
user: What is How Rigify Works and how is it used in Blender Python scripting?

assistant: Rigify Meta-Rigs are split in multiple Sub-Rigs
:   A meta-rig is an assembly of bone chains. A bone chain is identified by the *Connected* attribute.
    Bone chains can be further connected together by parenting them without using the *Connected* attribute
    (i.e. using the *Keep Offset* option while parenting).

A custom attribute is set on the first bone of the sub-rig chain
:   Each first bone of a bone chain has a custom attribute on it which is a Rigify custom property
    that identifies the sub-rig type. At rig generation time Rigify will determine which controls and
    deform bones will be created processing the meta-rig from the first bone to the last of each chain.

    [image reference removed]

    Human meta-rig split by samples.

New meta-rigs are created assembling sub-rigs samples
:   Since a meta-rig is just a collection of sub-rigs,
    new meta-rigs can be built assembling sub-rigs in different ways.
    This way an infinite number of meta-rigs can be built from the same rigging blocks.

    [image reference removed]

    Cat meta-rig built by samples.

All the mechanics, deformation bones and widget are created on a single click
:   The meta-rig contains more information than the visualized bones.
    In fact at generation time Rigify will identify each sub-rig type and depending on
    the selected options will create all the sophisticated controls, switches, and
    deforming bones with a single click.
user: Provide the full official documentation entry for Collection Node, preserving all code examples.

assistant: # Collection Node

[[image reference removed]](../../../../_images/node-types_GeometryNodeInputCollection.webp)

The *Collection* input node outputs a single collection. It can be connected to other collection sockets
to make using the same collection in multiple places more convenient.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Blender’s physics system allows you to simulate a number of different real-world physical phenomena.
You can use these systems to create a variety of static and dynamic effects such as:

- Hair, grass, and flocks
- Rain
- Smoke and dust
- Water
- Cloth
- Jello
- etc.
user: Explain Surface in complete detail according to the official Blender documentation.

assistant: The surface shader defines the light emission from the environment into the scene.
The world surface is rendered as if it is very distant from the scene,
and as such there is no two-way interacting between objects in the scene and the environment,
only light coming in. The only shader accepted is the Background node with a color input and
strength factor for the intensity of the light.

### Image Based Lighting

For image based lighting,
use the Environment Texture node rather than the Image Texture node for correct mapping.
This supports *Equirectangular* (also known as latitude/longitude) for environment maps,
and *Mirror Ball* mapping for converting photos of mirror balls to environment maps.
user: Show practical ways to work with Editing in a Blender add-on or script – include code.

assistant: ### Moving Keypoints or Particles

- To move selected keypoints press `G`, or use one of the various other methods to move vertices.
- To move a particle root you have to turn off Keep *Root* in the Toolbar.
- You can do many of the things like with vertices, including scaling,
  rotating and removing (complete particles or single keys).
- You may not duplicate or extrude keys or particles,
  but you can subdivide particles which adds new keypoints
  Particle ‣ Subdivide.
- Alternatively you can re-key a particle
  Particle ‣ Rekey.

How smoothly the hair and particle paths are displayed depends on the *Path Steps*
setting in the Toolbar. Low settings produce blocky interpolation between points,
while high settings produce a smooth curve.

### Mirror

If you want to create an X axis symmetrical haircut you have to do following steps:

1. Select all particles with `A`.
2. Mirror the particles with Particle ‣ Mirror.
3. Turn on *X Mirror* in Sidebar Region ‣ Tool ‣ Options.

It may happen that after mirroring two particles occupy nearly the same place.
Since this would be a waste of memory and render time,
you can use *Merge by Distance* from the *Particle* menu.

### Unify Length

This tool is used to make all selected hair uniform length by finding the average length.

### Show/Hide

Hiding and unhiding of particles works similar as with vertices in the 3D Viewport.
Select one or more keypoints of the particle you want to hide and press `H`.
The particle in fact does not vanish, only the key points.

Hidden particles (i.e. particles whose keypoints are hidden)
do not react on the various brushes. But:

If you use *Mirror Editing* even particles with hidden keypoints may be moved,
if their mirrored counterpart is moved.

To unhide all hidden particles press `Alt`-`H`.
user: Show practical ways to work with Axis Angle Mode in a Blender add-on or script – include code.

assistant: This mode lets us define an axis (X, Y, Z) and a rotation angle (W) around that axis.

If we define the rotation using interactive rotations (with the rotation gizmo),
the values of X, Y and Z will not exceed 1.0 in absolute value, and W will be
comprised between 0 and 180 degrees.

If you wish to define rotations above 180° (e.g. to define multiple revolutions),
you will need to edit the W value directly, but as soon as you perform an interactive rotation,
that value will be adjusted again. Same thing goes for axis values.

This system is suitable for elements revolving around a fixed axis, or to animate one of the elements at a time
(either the axis or the angle).
The problem might come when animating (interpolating) both components at the same time: axis and angle.
The resulting effect might not be as expected.

The *Gimbal* gizmo in this rotation mode shows a set of three orthogonal axes in which the Z axis goes
along the defined rotation axis, i.e. it points towards the direction defined by the (X, Y, Z) point.

The axis-angle system is free from gimbal lock, but animation curves in this mode are not intuitive at all
when animating axis and angle at the same time, in which case they are difficult to understand and edit.
user: Give a detailed overview of Bone Parent: syntax, arguments, return values, common patterns.

assistant: Bone parenting allows you to make a certain bone in an armature the parent object of another object.
This means that when transforming an armature the child object will only move
if the specific bone is the child object of moves.

[image reference removed]

Three pictures of armatures with four bones.

In Fig. [Three pictures of armatures with four bones.](#fig-view3d-parent-bone-parent) with the 2nd bone being the bone parent of the child object cube.
The cube is only transformed if the 1st or 2nd bones are.
Notice altering the 3rd and 4th bones has no effect on the cube.

To use bone parenting, you must first select all the child objects you wish to parent to a specific armature bone,
then `Shift`-`LMB` select the armature object and switch it into Pose Mode and
then select the specific bone you wish to be the parent bone by `LMB` selecting it.
Once done press `Ctrl`-`P` and select bone from the *Set Parent To* pop-up menu.

Now transforming that bone in Pose Mode will result in the child objects also transforming.

### Relative Parenting

Bone relative parenting is an option you can toggle for each bone.
This works in the same way as bone parenting with one difference.

With bone parenting if you have parented a bone to some child objects and
you select that bone and switch it into Edit Mode and then move that bone;
When you switch back into Pose Mode on that bone,
the child object which is parented to that bone will snap back to the location of the bone in Pose Mode.

[image reference removed]

Single armature bone which has a child object cube parented to it using bone parenting.

In Fig. [Single armature bone which has a child object cube parented to it using bone parenting.](#fig-view3d-parent-bone-parent-child) the 1st picture shows the position of the cube and
armature before the bone is moved in Edit Mode.
2nd picture shows the position of the cube and armature after the bone was selected in Edit Mode,
moved and switched back into Pose Mode. Notice that the child object moves to the new location of the pose bone.

Bone relative parenting works differently;
If you move a parent bone in Edit Mode, when you switch back to Pose Mode,
the child objects will not move to the new location of the Pose Bone.

[image reference removed]

Single bone with bone relative parent to a cube.

In Fig. [Single bone with bone relative parent to a cube.](#fig-view3d-parent-bone-parent-relative) the 1st picture
shows the position of the cube and armature before the bone is moved in Edit Mode.
2nd picture shows the position of the cube and armature after the bone was selected in Edit Mode,
moved and switched back into Pose Mode.
Notice that the child object does not move to the new location of the pose bone.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Object.modifiers`](bpy.types.Object.html#bpy.types.Object.modifiers "bpy.types.Object.modifiers") - [`ObjectModifiers.active`](bpy.types.ObjectModifiers.html#bpy.types.ObjectModifiers.active "bpy.types.ObjectModifiers.active") | - [`ObjectModifiers.new`](bpy.types.ObjectModifiers.html#bpy.types.ObjectModifiers.new "bpy.types.ObjectModifiers.new") - [`ObjectModifiers.remove`](bpy.types.ObjectModifiers.html#bpy.types.ObjectModifiers.remove "bpy.types.ObjectModifiers.remove") |
user: Give a detailed overview of FunctionNodeIntegerMath(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeIntegerMath(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.FunctionNodeIntegerMath(*FunctionNode*)
:   Perform various math operations on the given integer inputs

    operation
    :   Type:
        :   enum in [Node Integer Math Items](bpy_types_enum_items/node_integer_math_items.html#rna-enum-node-integer-math-items), default `'ADD'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: - Move `G`
- Rotate `R`
- Scale `S`
- Shear `Shift`-`Ctrl`-`Alt`-`S`

Axis Locking

Transformations can be locked to an axis by pressing `X` or `Y` after one of the transform tools.
Also, holding the `MMB` will constrain movement to the X or Y axis.

### Vertex Slide

Vertex Slide will transform a vertex along one of its adjacent edges.
Use `Shift`-`V` to activate tool.
The nearest selected vertex to the mouse cursor will be the control one.
Move the mouse along the direction of the desired edge to specify the vertex position.
Then press `LMB` to confirm the transformation.

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one vertex, while positive ones, refer to the other one.

Even `E`
:   By default, the offset value of the vertices is a percentage of the edges length along which they move.
    When Even mode is active, the vertices are shifted by an absolute value.

Flipped `F`
:   When Flipped is active, vertices move the same distance from adjacent vertices,
    instead of moving from their original position.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

### Edge Slide

Slides one or more edges across adjacent faces with a few restrictions involving the selection
of edges (i.e. the selection *must* define a valid loop, see below).

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one face, while positive ones, refer to the other one.

Even `E`
:   Forces the edge loop to match the shape of the adjacent edge loop.
    You can flip to the opposite vertex using `F`.

Flipped `F`
:   When Even mode is active, this flips between the two adjacent edge loops the active edge loop will match.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

Mirror Editing
:   Lets you propagate the operation to the symmetrical elements of the mesh (if present, in local X direction).