PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Select Menu in complete detail according to the official Blender documentation.

assistant: The Select menu lets you select strips in different ways.

All `A`
:   Selects all the strips in the timeline.

None `Alt`-`A`
:   Deselects all the strips in the timeline.

Invert `Ctrl`-`I`
:   Inverts the current selection.

Box Select `B`
:   See [Box Select](../../../interface/selecting.xhtml#bpy-ops-select-box).

Box Select (Include Handles) `Ctrl`-`B`
:   Works like *Box Select*, but also selects any strip handles inside the box. If a strip has only
    one handle selected, dragging it will change the strip’s length. (If both handles are selected,
    the complete strip moves instead.)

Select Grouped `Shift`-`G`
:   Select strips that are similar to the active strip. By default, unsimilar strips are
    deselected, but this can be changed in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last)
    region.

    Type
    :   Select strips that have the same specific type as the active strip. For example,
        if the active strip is a Movie strip, this selects all Movie strips.

    Global Type
    :   Select strips that have the same general type (graphics or audio) as the active strip.

    Effect Type
    :   If the active strip is an effect strip, selects all effect strips. Otherwise,
        selects all non-effect strips. (Despite the name, this operator does not check
        the effect type.)

    Data
    :   Select strips that use the same source (file, scene, movie clip or mask) as the active strip.

    Effect
    :   Find the effect types that are applied to the active strip, and select all strips that have
        any of the same effect types applied to them. For example, if the active strip has a
        Gaussian Blur effect on it, this will select all other strips that are also blurred.

    Effect/Linked
    :   Select strips that are on a lower channel than a selected strip and overlap it in time;
        then, effect strips linked to the selected content strips; and finally, content strips
        linked to the selected effect strips.

    Overlap
    :   Select strips that partially or completely overlap the active strip in time.

Select Linked
:   All `Ctrl`-`L` / Less `Ctrl`-`NumpadMinus` / More `Ctrl`-`NumpadPlus`
    :   Add/remove neighboring strips to/from the selection.

Side of Frame
:   Left/Right `[`/`]`
    :   Select the strips that lie completely to the left or right of the current frame.

    Current
    :   Select the strips that intersect the current frame.

Handle
:   Both, Left, Right
    :   Select the left, right, or both handles of the selected strips.

    Both/Left/Right Neighbor
    :   Select the handle of the neighboring strip to the left, right, or on both sides of the selected strips.

Channel
:   Select all the strips that are in the same channels as the currently selected strips.
user: Describe Setting the Active Camera from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Active camera (left) displayed with a solid triangle above it.

This sets the current active object as the active camera and switches to the camera view.

The active camera is the one that will be used for rendering,
and which you’ll look through when choosing camera view.

Another way of setting the active camera is through the *Scene* tab of the
[Properties](../../properties_editor.html).

### Animated Camera Switching

While a scene contains only one camera by default, it’s possible to have multiple.
You can then bind the cameras to specific time points in your animation
to create jump cuts showing different viewpoints.
See [Animating Cameras](../../../animation/markers.html#bpy-ops-marker-camera-bind).
user: Explain Example in complete detail according to the official Blender documentation.

assistant: An example of a rig using bone envelopes and not weight painting.

|  |  |
| --- | --- |
| <../../../_images/modeling_modifiers_deform_corrective-smooth_example-pose-before.png>   Armature only. | <../../../_images/modeling_modifiers_deform_corrective-smooth_example-pose-after.png>   Armature and Corrective Smooth. |
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Rotation Type
:   Axis Angle:
    :   Use separate axis and angle inputs to control the rotation.

    Euler:
    :   Use an Euler input to control the rotation.

Space
:   Object:
    :   Rotate an Euler rotation in the evaluated object’s space.

    Local:
    :   Rotate an Euler rotation in local space.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Color
:   Color of the surface, or physically speaking,
    the probability that light is reflected or transmitted for each wavelength.

Roughness Cycles Only
:   Surface roughness; 0.0 gives standard Lambertian reflection, higher values activate the Oren-Nayar BSDF.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: What is Basic Setup and how is it used in Blender Python scripting?

assistant: The Spline IK Constraint is not strictly an *Inverse Kinematics* method (i.e. IK Constraint),
but rather a *Forward Kinematics* method (i.e. normal bone posing). However,
it still shares some characteristics of the IK Constraint,
such as operating on multiple bones, not being usable for Objects,
and being evaluated after all other constraints have been evaluated. It should be noted that
if a Standard IK chain and a Spline IK chain both affect a bone at the same time the Standard
IK chain takes priority. Such setups are best avoided though,
since the results may be difficult to control.

To setup Spline IK,
it is necessary to have a chain of connected bones and a curve to constrain these bones to:

1. With the last bone in the chain selected,
   add a [Spline IK](../../../../constraints/tracking/spline_ik.html)
   Constraint from the Bone Constraints tab in the Properties.
2. Set the *Chain Length* setting to the number of bones in the chain
   (starting from and including the selected bone) that should be influenced by the curve.
3. Finally, set the *Target* field to the curve that should control the curve.

Congratulations, the bone chain is now controlled by the curve.
user: What is Smooth Modifier and how is it used in Blender Python scripting?

assistant: # Smooth Modifier

The *Smooth* modifier smooths a mesh by flattening the angles between adjacent faces in it,
just like the [Smooth tool](../../meshes/editing/vertex/smooth_vertices.xhtml#bpy-ops-mesh-vertices-smooth) in Edit Mode.
It smooths without subdividing the mesh, the number of vertices remains the same.

This modifier is not limited to smoothing, though.
Its control factor can be configured outside the (0.0 to 1.0) range
(including negative values), which can result in interesting deformations.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketVectorAcceleration4D(NodeTreeInterfaceSocket), preserving all code examples.

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

assistant: # Join Strings Node

[image reference removed]

The *Join Strings* node combines any number of input strings into the output string.
The order of the result depends on the vertical ordering of the inputs in the multi-input socket.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

2D Stabilization panel.

Anchor Frame
:   Reference point to anchor stabilization:
    other frames will be adjusted relative to this frame’s position, orientation and scale.
    You might want to select a frame number where your main subject is featured in an optimal way.

Stabilization Type
:   Rotation
    :   In addition to location, stabilizes detected rotation around the *rotation pivot point*,
        which is the weighted average of all location tracking points.

    Scale
    :   Compensates any scale changes relative to center of rotation.

Tracks for Stabilization
:   Location
    :   List of tracks to be used to compensate for camera jumps, or location movement.

    Rotation/Scale
    :   List of tracks to be used to compensate for camera tilts and scale changes.

Autoscale
:   Finds smallest scale factor which, when applied to the footage,
    would eliminate all empty black borders near the image boundaries.

    Max
    :   Limits the amount of automatic scaling.

Expected Position X/Y
:   Known relative offset of original shot, will be subtracted, e.g. for panning shots.

Expected Rotation
:   Rotation present on original shot, will be compensated, e.g. for deliberate tilting.

Expected Zoom
:   Explicitly scale resulting frame to compensate zoom of original shot.

Influence
:   The amount of transformation applied to the footage can be controlled.
    In some cases it is not necessary to fully compensate camera jumps.
    The amount of stabilization applied to the footage can be controlled.
    In some cases you may not want to fully compensate some of the camera’s jumps.
    Please note that these “\* *Influence*” parameters do control only the *compensation movements*
    calculated by the stabilizer, not the deliberate movements added through the “*Expected* \*”-parameters.

Interpolate
:   The stabilizer calculates compensation movements with sub-pixel accuracy.
    Consequently, a resulting image pixel needs to be derived from several adjacent source footage pixels.
    Unfortunately, any interpolation causes some minor degree of softening and loss of image quality.

    Nearest
    :   No interpolation, uses nearest neighboring pixel.
        This setting basically retains the original image’s sharpness.
        The downside is we also retain residual movement below the size of one pixel,
        and compensation movements are done in 1 pixel steps, which might be noticeable as irregular jumps.

    Bilinear
    :   Simple linear interpolation between adjacent pixels.

    Bicubic
    :   Highest quality interpolation, most expensive to calculate.
user: Provide the full official documentation entry for VFX Platform, preserving all code examples.

assistant: Blender follows the [VFX reference platform](https://vfxplatform.com),
which means it is able to run on the same systems as other VFX software
and exchange image, volume and scene files with them.

### Python Version

Blender and the [bpy module](https://pypi.org/project/bpy/) are only compatible
with a single Python version. This makes it possible for add-ons and VFX software
in general to only have to target a single Python version.

Blender bundles a complete Python installation and does not interact with the
system Python by default. This can be changed with the `--python-use-system-env`
[command line argument](command_line/arguments.html#command-line-args-python-options), if care is
taken to set up a compatible Python version.
user: Describe LineStyleGeometryModifier_TipRemover(LineStyleGeometryModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleGeometryModifier_TipRemover(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_TipRemover(*LineStyleGeometryModifier*)
:   Remove a piece of stroke at the beginning and the end of stroke backbone

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    tip_length
    :   Length of tips to be removed

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_TipRemover.type "bpy.types.LineStyleGeometryModifier_TipRemover.type")
user: Explain Run a Function n times every x seconds in complete detail according to the official Blender documentation.

assistant: ```
import bpy

counter = 0

def run_10_times():
    global counter
    counter += 1
    print(counter)
    if counter == 10:
        return None
    return 0.1

bpy.app.timers.register(run_10_times)
```
user: How do I use Radial Tiling Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Radial Tiling Node

[image reference removed]

The *Radial Tiling Node* provides the ability to divide a 2D cartesian input coordinate system
into as many radial segments as specified by the *Sides* input.
Each segment has its own affinely transformed segment coordinate system,
which can be used to tile textures in a radially symmetric manner.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Cache File
:   Data-block menu to select the Alembic or USD file.

File Path
:   Path to Alembic or USD file.

Object Path
:   The path to the Alembic or USD object inside the archive or stage.

Read Data
:   Controls which mesh data is imported from the cache file.
    You can selectively enable or disable the following:

    Vertices:
    :   Reads vertex positions and (if animated) deformations for each frame.

    Faces:
    :   Imports the mesh’s face topology and structure.

    UV:
    :   Loads UVs (texture coordinates) from the cache file.

    Color:
    :   Imports vertex color attributes from the cache file, if present.

    Attributes:
    :   Loads custom attributes (e.g., other data such as creases, custom normals, or generic attributes).

### Time

Sequence
:   Whether or not the cache is separated in a series of files.

Override Frame
:   Whether to use a custom frame for looking up data in the cache file,
    instead of using the current scene frame.

    The *Frame* value is the time to use for looking up the data in the cache file,
    or to determine which to use in a file sequence.

Frame Offset
:   Subtracted from the current frame to use for looking up the data in the cache file,
    or to determine which file to use in a file sequence.

### Velocity

Velocity Attribute
:   The name of the Alembic attribute used for generating motion blur data;
    by default, this is `.velocities` which is standard for most Alembic files.

Velocity Unit
:   Defines how the velocity vectors are interpreted with regard to time.

    Frame:
    :   The velocity unit was encoded in frames and does not need to be scale by scene FPS.

    Second:
    :   The velocity unit was encoded in seconds and needs to be scaled by the scene FPS (1 / FPS).

Velocity Scale
:   Multiplier used to control the magnitude of the velocity vector for time effects such as motion blur.
user: Show practical ways to work with OperatorMacro(bpy_struct) in a Blender add-on or script – include code.

assistant: # OperatorMacro(bpy_struct)

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

*class* bpy.types.OperatorMacro(*bpy_struct*)
:   Storage of a sub operator in a macro after it has been added

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The Build modifier can be used to make a large number of items to progressively appear,
without resorting to animating the visibility of each one by one. Examples of this include
a mesh containing vertices only, which is used as
an [Instancing Vertex emitter](../../../scene_layout/object/properties/instancing/verts.xhtml),
and has the Build modifier on it. Such a setup is a workaround/technique for being able to art-direct
a semi-random layout of a collection of objects (e.g. leaves/balls forming a carpet).
This can be preferable to particles e.g. due to undesirable distribution of items leaving random gaps
and overlapping in other places.
user: Explain Tips in complete detail according to the official Blender documentation.

assistant: - To get the patch file, add .patch to the end of the URL of the pull request. Example:

  ```
  https://projects.blender.org/blender/blender-manual/pulls/104892.patch
  ```
- Checkout a pull request into a detached head (not leaving behind a branch). Example:

  ```
  git fetch -q origin +refs/pull/104892/head: ; git checkout -qf FETCH_HEAD
  ```
user: How do I use Ocean Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Ocean Modifier

The *Ocean* modifier is a tool to simulate and generate a deforming ocean surface,
and associated texture, used to render the simulation data.
It is intended to simulate deep ocean waves and foam.

It is a port from the open source [Houdini Ocean Toolkit](https://code.google.com/archive/p/houdini-ocean-toolkit/).
user: Show practical ways to work with Documenting New Features and Changes in a Blender add-on or script – include code.

assistant: # Documenting New Features and Changes

With every Blender release, exciting new features, improvements, and changes are introduced. To ensure Blender users
can make the most of these updates, the documentation needs to be updated in parallel.

The Blender documentation project tracks changes requiring updates or additions to the manual. By contributing, you
help keep the manual accurate and valuable for the global Blender community.

This guide will walk you through the process of documenting these changes using release issues and commit logs.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: 1. Place the timeline playhead between two existing Grease Pencil keyframes.
2. In the 3D Viewport, click and drag left to right to set the desired interpolation factor.
3. Release the mouse button to confirm and create a new *breakdown keyframe*.

The resulting keyframe contains strokes that are interpolated between the neighboring keyframes
according to the chosen factor.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Pixelate Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| <../../_images/grease-pencil_visual-effects_pixelate_size-0.png>   Original image. | <../../_images/grease-pencil_visual-effects_pixelate_size-20.png>   Size: 20 px. | <../../_images/grease-pencil_visual-effects_pixelate_size-100.png>   Size: 100 px. | <../../_images/grease-pencil_visual-effects_pixelate_size-200.png>   Size: 200 px. |
user: How do I use Drivers in Blender? Include parameters, examples, warnings and best practices.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Linux, graphics drivers are usually installed as a package by your Linux distribution. Installing the latest
drivers is typically done by upgrading packages or the distribution as a whole. Some distributions provide multiple
packages for multiple drivers versions, giving you the choice to install newer versions.

A lot of fixes for AMD and Intel GPUs are backported into the Mesa drivers. Therefore it is recommended to install or upgrade to their latest point [releases](https://docs.mesa3d.org/relnotes.html). For certain Linux distribution versions this can be done using custom repositories. For example, using the [kisak-mesa PPA](https://launchpad.net/~kisak/+archive/ubuntu/kisak-mesa) for Ubuntu.
user: What is Gesture Tools and how is it used in Blender Python scripting?

assistant: # Gesture Tools

Separate from brushes and filters, Sculpt mode also has a set of tools that perform actions to a drawn
selection area. These tools are similar to the selection tools (e.g. [box selection](../../../interface/selecting.xhtml#tool-select-box)
and [lasso selection](../../../interface/selecting.xhtml#tool-select-lasso) in other areas of Blender).

These tools do not provide a selection of elements that are then modified, they directly modify the underlying
mesh.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Repeat Items
:   [List View](../../../interface/controls/templates/list_view.xhtml#ui-list-view) for adding, removing, reordering, and renaming the inputs of the zone.

    Socket Type
    :   The [data type](../../../modeling/geometry_nodes/attributes_reference.xhtml#attribute-data-types) of the selected input.

Inspection Index
:   The number of the iteration to show in [socket inspection](../../../modeling/geometry_nodes/inspection.xhtml#socket-inspection)
    and in the [Viewer Node](../../../modeling/geometry_nodes/output/viewer.xhtml).
user: How do I use Bpy.Types.Action in Blender? Include parameters, examples, warnings and best practices.

assistant:  bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values ID.bl_system_properties_get ID.rename ID.evaluated_get ID.copy ID.asset_mark ID.asset_clear ID.asset_generate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py References ¶ bpy.context.active_action bpy.context.selected_editable_actions bpy.context.selected_visible_actions ActionConstraint.action AnimData.action AnimData.action_tweak_storage BlendData.actions BlendDataActions.new BlendDataActions.remove GLTF2_filter_action.action NlaStrip.action NlaStrips.new Pose.apply_pose_from_action Pose.backup_create Pose.blend_pose_from_action WindowManager.poselib_previous_action Next ActionChannelbag(bpy_struct) Previous ASSETBROWSER_UL_metadata_tags(UIList) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Action(ID) Action Action.curve_frame_range Action.frame_end Action.frame_range Action.frame_start Action.is_action_layered Action.is_action_legacy Action.is_empty Action.layers Action.pose_markers Action.slots Action.use_cyclic Action.use_frame_range Action.deselect_keys() Action.fcurve_ensure_for_datablock() Action.flip_with_pose() Action.bl_rna_get_subclass() Action.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe CompositorNodeLevels(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeLevels(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.CompositorNodeLevels(*CompositorNode*)
:   Compute average and standard deviation of pixel values

    *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: Describe Adding & Removing Constraints from the Blender manual or Python API, including usage steps and snippets.

assistant: To add a constraint, click on *Add Object/Bone Constraint* in the [Properties Editor](../../editors/properties_editor.xhtml)
and choose a constraint type.

To remove a constraint, click its  button.

To move a constraint to a different position in the stack, drag its handle .

The [Constraints](../../scene_layout/object/editing/constraints.xhtml) menu in the 3D Viewport offers further options
such as copying constraints and deleting all constraints in one go.
The [Track](../../scene_layout/object/editing/track.xhtml) menu allows quickly adding a “track” (point at)
constraint.
user: Show practical ways to work with AttributeGroupGreasePencil(bpy_struct) in a Blender add-on or script – include code.

assistant: # AttributeGroupGreasePencil(bpy_struct)

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

*class* bpy.types.AttributeGroupGreasePencil(*bpy_struct*)
:   Group of geometry attributes

    active
    :   Active attribute

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

    active_index
    :   Active attribute index or -1 when none are active

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

    new(*name*, *type*, *domain*)
    :   Add attribute to geometry

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name, Name of geometry attribute
            - **type** (enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items)) – Type, Attribute type
            - **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   New geometry attribute

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

    remove(*attribute*)
    :   Remove attribute from geometry

        Parameters:
        :   **attribute** ([`Attribute`](bpy.types.Attribute.html#bpy.types.Attribute "bpy.types.Attribute"), (never None)) – Geometry Attribute

    domain_size(*domain*)
    :   Get the size of a given domain

        Parameters:
        :   **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   Size, Size of the domain

        Return type:
        :   int in [0, inf]

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

assistant: # Shader Editor

The Shader Editor is used to edit materials which are used for [rendering](../render/index.xhtml).
Materials used by Cycles and EEVEE are defined using a node tree.
Therefore, the main window of the Shader editor is a [node editor](../interface/controls/nodes/index.xhtml).

[image reference removed]

Shader Editor with the default material node tree.

A list of all [shader nodes](../render/shader_nodes/index.xhtml) is available in the rendering section.
user: Give a detailed overview of Clean Up: syntax, arguments, return values, common patterns.

assistant: ### Decimate Curve

The *Decimate Curve* operator reduces the number of control points
while trying to maintain the curves original shape.
This operator works similar to its [mesh counterpart](../../meshes/editing/mesh/cleanup.html#bpy-ops-mesh-decimate).

Ratio
:   The percentage of control points to remove.
user: Explain Movie Distortion Node in complete detail according to the official Blender documentation.

assistant: # Movie Distortion Node

[image reference removed]

In the real world, all camera lenses produce some or the other sort of lens distortion.
But, whatever we render has got no distortion. So, this node helps in removing distortion from movies
or adding distortion to render to make our render blend in with the movie clip.

Usually, it is used while motion tracking.
user: Show practical ways to work with Adjustment Layer Strip in a Blender add-on or script – include code.

assistant: # Adjustment Layer Strip

The Adjustment Layer strip works like a regular input file strip except for the fact,
that it considers all strips below it as its input.

Real-world use cases, you want to add some last finishing color correction on top of parts of
your final sequence, timeline without messing with meta strips around.
Just add an adjustment layer on top and activate the color balance.

Or you can stack a primary color correction and several secondary color corrections on top of
each other (probably using the new mask input for area selection).
user: Describe 2D Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: # 2D Transform

The *2D Transform* modifier applies two-dimensional scaling and/or rotation to
the stroke backbone geometry. Scale is applied before rotation.

Pivot
:   The center (pivot point) of these 2D transformations can be:

    Stroke Center:
    :   The median point of the stroke.

    Stroke Start:
    :   The beginning point of the stroke.

    Stroke End:
    :   The end point of the stroke.

    Stroke Point Parameter:
    :   The *Stroke Point Parameter* factor controls where along the stroke the pivot point is
        (start point if set to 0.0; end point if set to 1.0).

    Absolute 2D Point:
    :   The *Pivot X* and *Y* values define the position of the pivot point in the final render
        (from the bottom left corner).

Scale X, Y
:   The scaling factors, in their respective axes.

Rotation Angle
:   The rotation angle.

[image reference removed]

2D Transform modifier
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_Three_Contours.zip)).
user: Provide the full official documentation entry for Splitting, preserving all code examples.

assistant: You can split up chains of Freestyle lines by enabling one of the following:

Min/Max 2D Angle
:   Splits chains of feature edges when they make a 2D angle above (or below) a minimum (or maximum) threshold.

2D Length
:   Splits chains when they are longer than the given value.

Material Boundary
:   Splits chains of feature edges if they cross from one material to another.

### Split Pattern

Splits the chains using the given dashed pattern (see also [Dashed Line](#dashed-line)).

Dash 1, 2, 3
:   Length of the specified dash for splitting.

Gap 1, 2, 3
:   Length of the specified gap for splitting.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The input geometry containing the hair curves whose radius will be modified.

Replace Radius
:   When enabled, the node replaces the existing radius attribute with a new one.
    When disabled, the new radius is multiplied with the existing value instead.

Radius
:   The base radius value applied to all curves when *Replace Radius* is enabled.
    This sets the overall scale of the hair thickness.

Shape
:   Defines how the radius changes along the curve.
    For example, this can create a tapered profile, with thicker roots and thinner tips.

Factor Min
:   The multiplier applied to the radius at the start (root) of each curve.
    Typically used to control how thick the curve starts.

Factor Max
:   The multiplier applied to the radius at the end (tip) of each curve.
    Typically used to control how thin the curve becomes toward the tip.
user: Explain Hints in complete detail according to the official Blender documentation.

assistant: Why would you use a lattice to deform a mesh instead of deforming the mesh itself in Edit Mode?
There are a couple of reasons for that:

- If your object has a large number of vertices, it would be difficult to edit portions of it quickly in Edit Mode.
  Using a lattice will allow you to deform large portions efficiently.
- The smooth deformation you get from a *Lattice* modifier can be hard to achieve manually.
- Multiple objects can use the same lattice, thus allowing you to edit multiple objects at once.
- Like all modifiers, it is non-destructive. Meaning all changes happen on top of the original geometry,
  which you can still go back to and edit without affecting the deformation.
- A lattice does not affect the texture coordinates of a mesh’s surface.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`GizmoGroup.setup_keymap`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.setup_keymap "bpy.types.GizmoGroup.setup_keymap") - [`KeyConfigurations.active`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.active "bpy.types.KeyConfigurations.active") - [`KeyConfigurations.addon`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.addon "bpy.types.KeyConfigurations.addon") - [`KeyConfigurations.default`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.default "bpy.types.KeyConfigurations.default") | - [`KeyConfigurations.new`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.new "bpy.types.KeyConfigurations.new") - [`KeyConfigurations.remove`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.remove "bpy.types.KeyConfigurations.remove") - [`KeyConfigurations.user`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.user "bpy.types.KeyConfigurations.user") - [`WindowManager.keyconfigs`](bpy.types.WindowManager.html#bpy.types.WindowManager.keyconfigs "bpy.types.WindowManager.keyconfigs") |
user: Explain NodeSeparateBundleItem(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # NodeSeparateBundleItem(bpy_struct)

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

*class* bpy.types.NodeSeparateBundleItem(*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'`

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

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

assistant: Pass Index
:   Index number for the *Material Index* [render pass](../layers/passes.html).
    This can be used to give a mask to a material which then can be read with
    the [ID Mask Node](../../compositing/types/mask/id_mask.html) in the Compositor.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Corner Angle
:   The internal angle at each face corner, measured in radians.
    For example, a right angle returns approximately `1.571`.

Bisector
:   A normalized vector pointing along the bisector of the corner angle,
    halfway between the directions of the two connected edges.
user: Describe Docking from the Blender manual or Python API, including usage steps and snippets.

assistant: Docking describes several ways an area a user can interactively manipulate
the size and location of areas along with splitting an area into new areas.

To start the interactive process, placing the mouse cursor
in an area corner will change the cursor to a cross (+).
Once the cursor is a cross, press and hold `LMB` to preform any of the following actions:

If you press `Esc` or `RMB` before releasing the mouse, the operation will be canceled.

### Joining

[image reference removed]

Properties is being joined to the Outliner.

Dragging from an area corner into the space of a second area will *join* two areas.
The areas that will be joined will be displayed brighter.

### Splitting

[image reference removed]

Splitting an area will create a new area.
Dragging from an area corner left/right will split the area vertically,
to split the area horizontally drag up/down.

You can split and join areas at once by dragging a split operation into a separate area.

Dragging an area into the middle of an second area will replace the second area with the first area.
user: Provide the full official documentation entry for BlendDataParticles(bpy_struct), preserving all code examples.

assistant: # BlendDataParticles(bpy_struct)

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

*class* bpy.types.BlendDataParticles(*bpy_struct*)
:   Collection of particle settings

    new(*name*)
    :   Add a new particle settings instance to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New particle settings data-block

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

    remove(*particle*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a particle settings instance from the current blendfile

        Parameters:
        :   - **particle** ([`ParticleSettings`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings "bpy.types.ParticleSettings"), (never None)) – Particle Settings to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of those particle settings before deleting them
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this particle settings
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this particle settings

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: Normal
:   Vector indicating the normal of each geometry element.

True Normal
:   For meshes, outputs normals without [custom normals](../../../meshes/structure.xhtml#modeling-meshes-normals-custom) attributes taken into
    account.
user: Explain CompositorNodeColorBalance(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeColorBalance(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.CompositorNodeColorBalance(*CompositorNode*)
:   Adjust color and values

    input_whitepoint
    :   The color which gets mapped to white (automatically converted to/from temperature and tint)

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

    output_whitepoint
    :   The color which gets white gets mapped to (automatically converted to/from temperature and tint)

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

    *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