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

assistant: # CompositorNodeMapUV(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.CompositorNodeMapUV(*CompositorNode*)
:   Map a texture using UV coordinates, to apply a texture to objects in compositing

    *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: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`FreestyleLineStyle.geometry_modifiers`](bpy.types.FreestyleLineStyle.html#bpy.types.FreestyleLineStyle.geometry_modifiers "bpy.types.FreestyleLineStyle.geometry_modifiers") |  |
user: How do I use Settings and Controls in Blender? Include parameters, examples, warnings and best practices.

assistant: For the precise list of options, see [Spline IK](../../../../constraints/tracking/spline_ik.html) constraint.
This section is intended to introduce the workflow.

### Roll Control

To control the [Roll](../../../../../glossary/index.html#term-Roll) of the Spline IK chain,
the standard methods of rotating the bones in the chain along their local Y axes still apply.
For example, start at the farthest bone and simply rotate the bones in the chain around their
local Y axes to adjust the roll of the chain from that point onward.

Applying Copy Rotation constraints on the bones also works.

### Offset Controls

The entire bone chain can be made to follow the shape of the curve while still being able to
be placed at an arbitrary point in 3D space when the *Chain Offset* option is enabled.
By default, this option is not enabled,
and the bones will be made to follow the curve in its untransformed position.

### Length Control

The *Y Scale Mode* setting can be used to choose the way bones are scaled length-wise.
The available options allow stretching the bone chain to fit the curve, using the pre-IK
scaling, or doing neither. In addition, the scale of the curve Object affects the result.

### Thickness Controls

The thickness of the bones in the chain is controlled using the constraint’s *XZ Scale Mode* setting.
This setting determines the method used for determining the scaling on
the X and Z axes of each bone in the chain.

The available modes are:

None
:   This option keeps the X and Z scaling factors as 1.0.

Volume Preserve
:   The X and Z scaling factors are taken as the inverse of the Y scaling factor (length of the bone),
    maintaining the ‘volume’ of the bone.

Bone Original
:   This options just uses the X and Z scaling factors the bone would have after being evaluated in the standard way.

In addition to these modes, there is an option, *Use Curve Radius*.
When this option is enabled, the average radius of the radii of the points on the curve where
the joints of each bone are placed, are used to derive X and Z scaling factors.
This allows the scaling effects, determined using the modes above,
to be tweaked as necessary for artistic control.
user: How do I use limbs.leg in Blender? Include parameters, examples, warnings and best practices.

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

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

[image reference removed]

Leg required bones.

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

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

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

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

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

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

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

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

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.
user: Provide the full official documentation entry for Beautify Faces, preserving all code examples.

assistant: # Beautify Faces

*Beautify Faces* works only on selected existing faces.
It rearrange selected triangles to obtain more “balanced” ones (i.e. less long thin triangles).

Max Angle
:   An angle delimiter option to limit edge rotation to flat surfaces.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_face_beautify-faces_before.png>   Text converted to a mesh. | <../../../../_images/modeling_meshes_editing_face_beautify-faces_after.png>   Result of Beautify Faces. |
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`NodeTree.interface`](bpy.types.NodeTree.html#bpy.types.NodeTree.interface "bpy.types.NodeTree.interface") | - [`UILayout.template_node_tree_interface`](bpy.types.UILayout.html#bpy.types.UILayout.template_node_tree_interface "bpy.types.UILayout.template_node_tree_interface") |
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Data Type
:   The data type of the grid to which the transform is applied.
    Determines the kind of values stored in the grid
    (e.g. *Float*, *Integer*, *Boolean*, *Vector*), and must match the input grid’s data type.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input.

Key Color
:   The color that is to be keyed.

Color Space
:   It is also possible to work with YCbCr color space,
    but only the Cb and Cr channels are taken into consideration
    for determining the distance between the foreground and background pixels.

    RGB, YCC

Tolerance
:   A threshold what the node considers a match between the key color and the foreground pixel.
    The tolerance affects how close a pixel needs to be to the background pixel
    to be considered an absolute match.

Falloff
:   When the Falloff value is high, pixels that are close to the Key Color are more
    transparent than pixels that are not as close to the Key Color
    (but still considered close enough to be keyed).
    When the Falloff value is low, it does not matter how close
    the pixel color (Image) is to the Key Color, it is transparent.
user: Provide the full official documentation entry for Bone Properties, preserving all code examples.

assistant: # Bone Properties

When bones are selected (hence in *Edit Mode* and *Pose Mode*), their
properties are shown in the *Bone* tab of the Properties.
This shows different panels used to control features of each selected bone;
the panels change depending on which mode you are working in.
user: Show practical ways to work with Select Loop Inner-Region in a Blender add-on or script – include code.

assistant: *Select Loop Inner-Region* selects all faces that are inside a closed loop of edges.
While it is possible to use this operator in *Vertex* and *Face* selection modes, results may be unexpected.
Note that if the selected loop of edges is not closed,
then all connected edges on the mesh will be considered inside the loop.

[image reference removed]

Loop to Region.

[image reference removed]

This tool handles multiple loops fine, as you can see.

[image reference removed]

This tool handles “holes” just fine as well.
user: Show practical ways to work with Bpy.Types.Spacedopesheeteditor in a Blender add-on or script – include code.

assistant: usually WINDOW . ( bpy.types.Region.type ) draw_type ( str ) – Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor. Returns : Handler that can be removed later on. Return type : object classmethod draw_handler_remove ( handler , region_type ) ¶ Remove a draw handler that was added previously. Parameters : handler ( object ) – The draw handler that should be removed. region_type ( str ) – Region type the callback was added to. Inherited Properties ¶ bpy_struct.id_data Space.type Space.show_locked_time Space.show_region_header Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items 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 Space.bl_rna_get_subclass Space.bl_rna_get_subclass_py Space.draw_handler_add Space.draw_handler_remove Next SpaceDopeSheetOverlay(bpy_struct) Previous SpaceConsole(Space) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page SpaceDopeSheetEditor(Space) SpaceDopeSheetEditor SpaceDopeSheetEditor.cache_cloth SpaceDopeSheetEditor.cache_dynamicpaint SpaceDopeSheetEditor.cache_particles SpaceDopeSheetEditor.cache_rigidbody SpaceDopeSheetEditor.cache_simulation_nodes SpaceDopeSheetEditor.cache_smoke SpaceDopeSheetEditor.cache_softbody SpaceDopeSheetEditor.dopesheet SpaceDopeSheetEditor.mode SpaceDopeSheetEditor.overlays SpaceDopeSheetEditor.show_cache SpaceDopeSheetEditor.show_extremes SpaceDopeSheetEditor.show_interpolation SpaceDopeSheetEditor.show_markers SpaceDopeSheetEditor.show_pose_markers SpaceDopeSheetEditor.show_region_channels SpaceDopeSheetEditor.show_region_footer SpaceDopeSheetEditor.show_region_hud SpaceDopeSheetEditor.show_region_ui SpaceDopeSheetEditor.show_seconds SpaceDopeSheetEditor.show_sliders SpaceDopeSheetEditor.ui_mode SpaceDopeSheetEditor.use_auto_merge_keyframes SpaceDopeSheetEditor.use_marker_sync SpaceDopeSheetEditor.use_realtime_update SpaceDopeSheetEditor.bl_rna_get_subclass() SpaceDopeSheetEditor.bl_rna_get_subclass_py() SpaceDopeSheetEditor.draw_handler_add() SpaceDopeSheetEditor.draw_handler_remove() Inherited Properties Inherited Functions
user: What is UIPopupMenu(bpy_struct) and how is it used in Blender Python scripting?

assistant: # UIPopupMenu(bpy_struct)

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

*class* bpy.types.UIPopupMenu(*bpy_struct*)
:   layout
    :   Type:
        :   [`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (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: Explain Properties in complete detail according to the official Blender documentation.

assistant: Clamp Type
:   Method to clamp.

    Min Max:
    :   Constrain values between Min and Max.

    Range:
    :   Constrain values between Min and Max. When Min is greater than Max,
        constrain between Max and Min instead.
user: Provide the full official documentation entry for Getting Started, preserving all code examples.

assistant: To begin compositing, open the *Compositor* and create a new node tree
by clicking the [New](../editors/compositor.html#bpy-ops-node-new-compositing-node-group) button in the header.
This adds a compositing node tree data block to the scene, which can then be reused
across different scenes or linked/appended from other blend-files.

Once a node tree is created, you will see your first basic setup.
From here you can add and connect many types of
[Compositing Nodes](index.html) in a node graph layout
to build effects ranging from simple color corrections to complex composites.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Limit Location constraint.

Minimum/Maximum X, Y, Z
:   The number fields determine the boundaries for each axis.
    The checkboxes determine whether each boundary applies.

Affect Transform
:   When the owner is manually moved around, restrict not just its
    [visual](../introduction.xhtml#constraint-visual-transform) position but also its
    *Location* in the [Properties Editor](../../../editors/properties_editor.xhtml)’s *Transform* panel.

[Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The space for determining and limiting the position of the owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: How do I use Asset Library Type Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Asset Library Type Items

ALL:
:   All Libraries.

    Show assets from all of the listed asset libraries.

LOCAL:
:   Current File.

    Show the assets currently available in this Blender session.

ESSENTIALS:
:   Essentials.

    Show the basic building blocks and utilities coming with Blender.

CUSTOM:
:   Custom.

    Show assets from the asset libraries configured in the Preferences.
user: Provide the full official documentation entry for Hotkeys, preserving all code examples.

assistant: Free-Align Toggle
:   Hold `LeftShift` while dragging a handle to switch between `Free` and `Align` handle types.
    Can be used to create sharp corners along the curve.

Move Adjacent Handle
:   Hold `LeftCtrl` while dragging a handle to move the closer handle of the adjacent control point.
    Can be helpful to make adjustments to newly created curve segments.

Move Entire
:   Hold `Spacebar` while dragging a handle to move the entire point.

Link Handles
:   Press `RightCtrl` while dragging a handle to mirror its movement on the opposite handle of the same point.

Lock Handle Angle
:   Hold `LeftAlt` while dragging a handle to limit the movement of the handle to its current direction,
    so only its length can be adjusted.
user: Describe Gamma Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Gamma Node

[image reference removed]

Use this node to apply a gamma correction. The node is typically used to convert from gamma encoded to linear
color space, or in the reverse direction with 1/gamma.
user: Give a detailed overview of Draw Face Sets: syntax, arguments, return values, common patterns.

assistant: # Draw Face Sets

Draw new or extend existing [Face Sets](../editing/face_sets.xhtml#sculpting-editing-facesets) with each stroke.

Holding `Ctrl` will continue drawing the same face set as the one under the cursor.
Holding `Shift` will relax or smooth the edges of the face sets
by modifying the underlying topology so edges flow along the perimeter of the face sets.
This will remove the jagged lines visible after drawing or creating a face set.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.active_bone`](bpy.context.html#bpy.context.active_bone "bpy.context.active_bone") - [`bpy.context.edit_bone`](bpy.context.html#bpy.context.edit_bone "bpy.context.edit_bone") - [`bpy.context.editable_bones`](bpy.context.html#bpy.context.editable_bones "bpy.context.editable_bones") - [`bpy.context.selected_bones`](bpy.context.html#bpy.context.selected_bones "bpy.context.selected_bones") - [`bpy.context.selected_editable_bones`](bpy.context.html#bpy.context.selected_editable_bones "bpy.context.selected_editable_bones") - [`bpy.context.visible_bones`](bpy.context.html#bpy.context.visible_bones "bpy.context.visible_bones") - [`Armature.edit_bones`](bpy.types.Armature.html#bpy.types.Armature.edit_bones "bpy.types.Armature.edit_bones") | - [`ArmatureEditBones.active`](bpy.types.ArmatureEditBones.html#bpy.types.ArmatureEditBones.active "bpy.types.ArmatureEditBones.active") - [`ArmatureEditBones.new`](bpy.types.ArmatureEditBones.html#bpy.types.ArmatureEditBones.new "bpy.types.ArmatureEditBones.new") - [`ArmatureEditBones.remove`](bpy.types.ArmatureEditBones.html#bpy.types.ArmatureEditBones.remove "bpy.types.ArmatureEditBones.remove") - [`EditBone.bbone_custom_handle_end`](#bpy.types.EditBone.bbone_custom_handle_end "bpy.types.EditBone.bbone_custom_handle_end") - [`EditBone.bbone_custom_handle_start`](#bpy.types.EditBone.bbone_custom_handle_start "bpy.types.EditBone.bbone_custom_handle_start") - [`EditBone.parent`](#bpy.types.EditBone.parent "bpy.types.EditBone.parent") |
user: What is Overview and how is it used in Blender Python scripting?

assistant: To display an image, it must be converted from
[scene linear](color_spaces.html#color-management-linear-space) to a display color space.
This involves both technical and artistic choices.

The technical choice of [display color space](#bpy-types-colormanageddisplaysettings-display-device)
depends on the target display device and its capabilities. sRGB works for all
computer displays, but different choices may be made for digital cinema, HD TVs,
and computers with wide gamut or HDR support.

Because display devices cannot display the full spectrum of colors and only have
limited brightness, colors must be fitted to the gamut of the device. Blender
includes a choice of [views](#bpy-types-colormanagedviewsettings-view-transform),
each resulting in a different look.

Further artistic choices can be made with color management settings like exposure and
white balance, and color grading in the compositor.
.

[[image reference removed]](../../_images/render_color-management_linear-display-space.svg)

Conversion from linear to display device space.
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.

For NVIDIA, there are open source (Nouveau) and closed source (by NVIDIA) graphics drivers. Blender functions best
with the closed source drivers as they are more optimized and complete. Linux graphics drivers can be downloaded from
NVIDIA’s website, however in most cases the ones from your Linux distribution are fine and make things easier.
Manually downloading drivers is mostly useful to get the very latest version, for example for a GPU that was only
recently released.

Note, drivers before 550 do not support Vulkan!

[NVIDIA Website](https://www.nvidia.com/Download/index.aspx)
user: Describe Filter Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Tools for applying effects on the entire unmasked and visible mesh.

[Mesh Filter](tools/mesh_filter.xhtml)
:   Apply a deformation to all unmasked vertices.

[Cloth Filter](tools/cloth_filter.xhtml)
:   Applies a cloth simulation to all unmasked vertices.

[Color Filter](tools/color_filter.xhtml)
:   Changes the active color attribute on all unmasked vertices.
user: Show practical ways to work with Footer in a Blender add-on or script – include code.

assistant: Some editors show a bar (on top/bottom of the editor area)
that displays information about for example the active tool or operator.

In animation editors, the footer contains controls and options related to playback, keying, auto keyframing, and
transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.
user: What is Show All Operators and how is it used in Blender Python scripting?

assistant: While Blender logs operators in the Info editor,
this only reports operators with the `REGISTER` option enabled so as not to flood the *Info* view
with calls to `bpy.ops.view3d.smoothview` and `bpy.ops.view3d.zoom`.
Yet for testing it can be useful to see **every** operator called in a terminal,
do this by enabling the debug option either by passing the `--debug-wm` argument when starting Blender
or by setting [`bpy.app.debug_wm`](bpy.app.html#bpy.app.debug_wm "bpy.app.debug_wm") to `True` while Blender is running.
user: How do I use Query Parameters in Blender? Include parameters, examples, warnings and best practices.

assistant: When Blender fetches the extensions listing it passes the following arguments to make sure only
compatible extensions are listed:

- `platform`
- `blender_version`

These arguments are passed as parameters to the server via a query URL:

> URL:
> :   `https://extensions.blender.org/api/v1/extensions/`
>
> query URL:
> :   `https://extensions.blender.org/api/v1/extensions/?blender_version=4.2.0&platform=linux-x64`
user: What is Bpy.Types.Movietrackingtrack and how is it used in Blender Python scripting?

assistant: et bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items 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 References ¶ bpy.context.selected_movieclip_tracks MovieTracking.tracks MovieTrackingObject.tracks MovieTrackingObjectPlaneTracks.active MovieTrackingObjectTracks.active MovieTrackingObjectTracks.new MovieTrackingStabilization.rotation_tracks MovieTrackingStabilization.tracks MovieTrackingTracks.active MovieTrackingTracks.new UILayout.template_marker Next MovieTrackingTracks(bpy_struct) Previous MovieTrackingStabilization(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page MovieTrackingTrack(bpy_struct) MovieTrackingTrack MovieTrackingTrack.annotation MovieTrackingTrack.average_error MovieTrackingTrack.bundle MovieTrackingTrack.color MovieTrackingTrack.correlation_min MovieTrackingTrack.frames_limit MovieTrackingTrack.has_bundle MovieTrackingTrack.hide MovieTrackingTrack.lock MovieTrackingTrack.margin MovieTrackingTrack.markers MovieTrackingTrack.motion_model MovieTrackingTrack.name MovieTrackingTrack.offset MovieTrackingTrack.pattern_match MovieTrackingTrack.select MovieTrackingTrack.select_anchor MovieTrackingTrack.select_pattern MovieTrackingTrack.select_search MovieTrackingTrack.use_alpha_preview MovieTrackingTrack.use_blue_channel MovieTrackingTrack.use_brute MovieTrackingTrack.use_custom_color MovieTrackingTrack.use_grayscale_preview MovieTrackingTrack.use_green_channel MovieTrackingTrack.use_mask MovieTrackingTrack.use_normalization MovieTrackingTrack.use_red_channel MovieTrackingTrack.weight MovieTrackingTrack.weight_stab MovieTrackingTrack.bl_rna_get_subclass() MovieTrackingTrack.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Show practical ways to work with Action Properties in a Blender add-on or script – include code.

assistant: [image reference removed]

Actions with and without a Manual Frame Range in Dope Sheet.

It is possible to manually specify the intended useful frame range of an action via a panel
available in the [Dope Sheet](../editors/dope_sheet/introduction.xhtml) or the [NLA Editor](../editors/nla/sidebar.xhtml)
when a channel or NLA track is selected.

Manual Frame Range
:   Manually specify the intended playback frame range for the action
    (this range is used by some tools, but does not affect animation evaluation).
    The manual frame range feature can be toggled with the checkbox.

    When the range is set, it is used instead of the actual range occupied by key frames
    when adding a new track based on the action to NLA. It can also be used by exporters
    to determine the range of frames to export.

    The range is displayed in the background of the editor as diagonal hash fill, to
    distinguish it from the solid fill of the current playback range.

    The frame values are most commonly expected to be integers, but can be fractional.

Cyclic Animation
:   Specifies that the action is intended to be cyclic over the specified range. The first and last
    frames of the range should represent the same pose of the cycle one loop apart, i.e. the range
    should include the duplicated initial key of the loop.

### Slot

The properties of the action slot that is used by the currently selected item in the channel list.

Name
:   The name of the slot.

Type
:   The data-block type that the slot is intended to animate.

### Custom Properties

Create and manage your own properties to store data in the action’s data block.
See the [Custom Properties](../files/custom_properties.xhtml#files-data-blocks-custom-properties) page for more information.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Outer Mask
:   A mask representing the outside shape, which will fade from black at its edges
    to white at the *Inner Mask*.

Inner Mask
:   A mask representing the inside shape, which will be fully white.

Images Edges
:   The edges of the image that intersects the outer mask will be considered edges
    of the outer mask. Otherwise, the outer mask will be considered open-ended.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_matte_double-edge-mask_in.png   Disabled. | ../../../_images/compositing_types_matte_double-edge-mask_bleed.png   Enabled. |

Only Inside Outer
:   Only edges of the inner mask that lie inside the outer mask will be considered.
    Otherwise, all edges of the inner mask will be considered.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_matte_double-edge-mask_all.png   Disabled. | ../../../_images/compositing_types_matte_double-edge-mask_adjacent.png   Enabled. |
user: What is 3D Cursor and how is it used in Blender Python scripting?

assistant: Cursor – Surface Project
:   When placing the cursor by clicking,
    the cursor is projected onto the surface under the cursor.

Cursor – Lock Adjust
:   When the viewport is locked to the cursor,
    moving the cursor avoids the view *jumping* based on the new offset.
user: Provide the full official documentation entry for Metadata, preserving all code examples.

assistant: Metadata on parameters controls how they are displayed in the user interface.
The following metadata entries are supported:

`[[ string label = "My Label" ]]`
:   Custom display name of the parameter in the user interface.

`[[ string widget = "null" ]]`
:   Hides the parameter from the user interface.

`[[ string widget = "boolean" ]]` or `[[ string widget = "checkbox" ]]`
:   Displays an integer parameter as a boolean checkbox.

`[[ string widget = "filename" ]]`
:   Displays the parameter as a file path selector.

`[[ string widget = "mapper", string options = "left:0|right:1" ]]`
:   Displays an integer parameter as an enumerated menu.
    The *options* string defines a list of label-value pairs separated by `|`.

`[[ string vecsemantics = "POINT" ]]`
:   Marks a vector parameter as a translation input (position vector).

`[[ string vecsemantics = "NORMAL" ]]`
:   Marks a vector parameter as a normal input (direction vector).

`[[ string unit = "radians" ]]`
:   Marks a float parameter as an angle input, displayed in radians.

`[[ string unit = "m" ]]`
:   Marks a float parameter as a distance input, displayed in meters.

`[[ string unit = "s" ]]` or `[[ string unit = "sec" ]]`
:   Marks a float parameter as a time input, displayed in seconds.
user: What is Bone Colors and how is it used in Blender Python scripting?

assistant: Bones can be individually colored. You can either choose a color set from the predefined
[theme](../../../../editors/preferences/themes.html#bpy-types-theme) list or define a custom one.

[image reference removed]

When selecting *Custom Color Set*, you need to define three colors:
Regular (for when the bone is not selected), Selected, and Active.

You can temporarily disable all the color assignments by unchecking
[Bone Colors](../../properties/display.html#bpy-types-armature-show) in the armature’s Viewport Display panel.

Bone Color
:   The bone’s primary color, affecting both Edit Mode and Pose Mode.

    This color is stored on the armature data-block, so that if you have
    multiple armature objects that share this data-block, they will all use
    the same color.

    Copy Bone Color to Selected
    :   Copy the bone color of the [Active](../../../../glossary/index.html#term-Active) bone to all selected bones.

Pose Bone Color Pose Mode
:   Lets you optionally override the above *Bone Color* in Pose Mode
    (by setting it to something else than *Default Colors*).

    This color is stored on the [Pose Bone](../../../../glossary/index.html#term-Pose-Bone), meaning it can be different
    in every armature object – even ones that reference the same data-block.

    Copy Bone Color to Selected
    :   Copy the bone color of the [Active](../../../../glossary/index.html#term-Active) bone to all selected bones.
user: Provide the full official documentation entry for Recalculate Handles, preserving all code examples.

assistant: The *Recalculate Handles* operator rotates the selected control point’s handle to be tangential to the curve.
This can be used to make curves smoother and more consistent looking.

Length
:   Recalculates the length of the handles so they are all the same length.
user: Show practical ways to work with Menus in a Blender add-on or script – include code.

assistant: # Menus

Blender uses a variety of different menus for accessing options and [Operators](../../operators.html).
Menus can be interacted with in the following ways:

Mouse selection
:   `LMB` on the desired item.

Numerical selection
:   You can use the number keys or numpad to input an item in the list to select.
    For example, `Numpad1` will select the first item and so on.

If a menu is too large to fit on the screen, a small
scrolling triangle appears on the top or bottom.
Scrolling is done by moving the mouse above or below this triangle.

Shortcuts

- Use `Wheel` while hovering with the mouse.
- Arrow keys can be used to navigate.
- Each menu item has an underlined character which can be pressed to activate it.
- Number keys or numpad can also be used to activate menu items.
  (`1` for the first menu item, `2` for the second etc.
  For larger menus, `Alt`-`1` activates the 11th and so on, up to `Alt`-`0` for the 20th.)
- Press `Return` to activate the selected menu item.
- Press `Esc` to close the menu without activating any menu item. This can also be
  done by moving the mouse cursor far away from the menu, or by `LMB` clicking anywhere
  outside of it.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Domain
:   The [attribute domain](../attributes_reference.xhtml#attribute-domains) used to evaluate the *Value* input.
    The *Auto* option chooses the domain automatically based on the connected nodes.

### Viewer Items

Socket Type
:   The data type used to evaluate the input.

Auto Remove
:   Remove the item automatically when it is unlinked.
user: Show practical ways to work with GeometryNodeFieldMinAndMax(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeFieldMinAndMax(GeometryNode)

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

*class* bpy.types.GeometryNodeFieldMinAndMax(*GeometryNode*)
:   Calculate the minimum and maximum of a given field

    data_type
    :   Type of data the outputs are calculated from

        - `FLOAT`
          Float – Floating-point value.
        - `INT`
          Integer – 32-bit integer.
        - `FLOAT_VECTOR`
          Vector – 3D vector with floating-point values.

        Type:
        :   enum in [`'FLOAT'`, `'INT'`, `'FLOAT_VECTOR'`], default `'FLOAT'`

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`DynamicPaintModifier.canvas_settings`](bpy.types.DynamicPaintModifier.html#bpy.types.DynamicPaintModifier.canvas_settings "bpy.types.DynamicPaintModifier.canvas_settings") |  |
user: How do I use Node Groups in Blender? Include parameters, examples, warnings and best practices.

assistant: # Node Groups

[image reference removed]

Example of a node group.

Grouping nodes can simplify a node tree by hiding complexity and reusing common functionality.
A node group is visually identified by its green title bar.

Conceptually, node groups allow you to treat a *set* of nodes as a single unit.
They are similar to functions in programming: reusable, composable, and parametrizable.

For example, suppose you create a “Wood” material and want to use it in multiple colors.
You could duplicate the entire node setup for each color, but maintaining those duplicates
would be tedious if you later decide to change the wood grain detail.
Instead, you can move the nodes that generate the wood pattern into a node group.
Each material can then reuse this group and supply a custom color as input.
Any updates to the grain detail need to be made only once—inside the node group.

Node groups can be nested; that is, a group can contain other groups.

*Group Input* and *Group Output* nodes are used to represent data flowing into and out of the group.

The *Group Input* node provides access to the group’s input sockets from within the node group.
These sockets act as parameters that control the behavior of the group from the outside.
You can connect them to internal nodes to drive values such as factors, colors, or geometry inputs.

The *Group Output* node defines the data that is passed out of the node group.
Only sockets connected to this node will be available as outputs on the group itself.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

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

Amount
:   Controls the strength of the smoothing operation.
    Positive values smooth the curves by averaging point positions.
    Negative values exaggerate the differences between points, creating a crumpled or distorted effect.

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

Iterations
:   The number of smoothing steps applied.
    Increasing this value produces smoother results but may increase processing time.

Weight
:   A per-point weighting factor that controls how much each point contributes to the smoothing.
    Values closer to 0 reduce smoothing influence at those points.

Lock Tips
:   When enabled, the tips of the curves remain fixed, preventing them from moving during smoothing.

Preserve Length
:   When enabled, maintains the original length of each curve during deformation.
    When disabled, smoothing may slightly shorten the curves.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Armature modifier.

Object
:   The name of the armature object used by this modifier.

Vertex Group
:   The name of a vertex group of the object, the weights of which will be used to determine the influence of this
    Armature Modifier’s result when mixing it with the results from other *Armature* ones.

    Only meaningful when having at least two of these modifiers on the same object,
    with *Multi Modifier* activated.

    Invert
    :   Inverts the influence set by the vertex group defined in previous setting
        (i.e. reverses the weight values of this group).

Bind to
:   Vertex Groups
    :   When enabled, bones of a given name will deform points which belong to
        [vertex groups](../../../modeling/meshes/properties/vertex_groups/index.xhtml) of the same name.
        E.g. a bone named “forearm”, will only affect the points in the “forearm” vertex group.

        The influence of one bone on a given point is controlled by the weight of this point in the relevant group.
        A much more precise method than *Bone Envelopes*, but also generally longer to set up.

    Bone Envelopes
    :   When enabled, bones will deform points or control points near them,
        defined by each bone’s envelope radius and distance.
        Enable/Disable bone [envelopes](../../../animation/armatures/bones/properties/deform.xhtml#armature-bones-envelope) defining the deformation
        (i.e. bones deform points in their neighborhood).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Limit Distance constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to stay close to/keep away from.

Distance
:   The limit distance, i.e. the radius of the constraining sphere. It’s calculated
    automatically when selecting the first target.

    (Reset Distance)
    :   Set the *Distance* to the current distance between owner and target.

Clamp Region
:   How to constrain the owner relative to the spherical boundary:

    Inside:
    :   Keep the owner trapped within the sphere.

    Outside:
    :   Prevent the owner from entering the sphere.

    On Surface:
    :   Constrain the owner to the surface of the sphere.

Affect Transform
:   When the owner is manually moved around, restrict not just its
    [visual](../introduction.xhtml#constraint-visual-transform) position but also its
    *Location* in the [Properties Editor](../../../editors/properties_editor.xhtml)’s *Transform* panel.

[Target/Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The spaces for retrieving the position of the target and for applying the constrained result to the owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Give a detailed overview of Camera View: syntax, arguments, return values, common patterns.

assistant: # Camera View

[image reference removed]

Demonstration of camera view.

The Camera view shows the current scene from the active camera’s viewpoint.

The Camera view can be used to virtually compose shots and preview how the scene will look when rendered.
The rendered image will contain everything within the dashed frame.
user: Show practical ways to work with Limitations in a Blender add-on or script – include code.

assistant: The following selections are not supported by the rip operator and will give an error message:

- Face(s), including when selecting vertices or edges that form up a face.
- Edges or vertices that are not “between” two faces (non [Manifold](../../../../glossary/index.xhtml#term-Manifold)).
- Two vertices that aren’t connected to each other.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Child Of constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The parent object or bone.

Location
:   The location axes of the child to affect.

Rotation
:   The rotation axes of the child to affect.

Scale
:   The scale axes of the child to affect.

Set Inverse
:   If the child’s transform is correct with the constraint disabled but incorrect with the
    constraint enabled, click this button to fix it.

Clear Inverse
:   Tells the constraint that the child’s current transform with the constraint disabled is its
    correct *relative* transform. Once the constraint is enabled again, this transform will be
    applied as an offset to the parent to determine the child’s final transform.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Describe GeometryNodeTree(NodeTree) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeTree(NodeTree)

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

*class* bpy.types.GeometryNodeTree(*NodeTree*)
:   Node tree consisting of linked nodes used for geometries

    is_mode_edit
    :   The node group is used in edit mode

        Type:
        :   boolean, default False

    is_mode_object
    :   The node group is used in object mode

        Type:
        :   boolean, default False

    is_mode_paint
    :   The node group is used in paint mode

        Type:
        :   boolean, default False

    is_mode_sculpt
    :   The node group is used in sculpt mode

        Type:
        :   boolean, default False

    is_modifier
    :   The node group is used as a geometry modifier

        Type:
        :   boolean, default False

    is_tool
    :   The node group is used as a tool

        Type:
        :   boolean, default False

    is_type_curve
    :   The node group is used for curves

        Type:
        :   boolean, default False

    is_type_grease_pencil
    :   The node group is used for Grease Pencil

        Type:
        :   boolean, default False

    is_type_mesh
    :   The node group is used for meshes

        Type:
        :   boolean, default False

    is_type_pointcloud
    :   The node group is used for point clouds

        Type:
        :   boolean, default False

    show_modifier_manage_panel
    :   Turn on the option to display the manage panel when creating a modifier

        Type:
        :   boolean, default False

    use_wait_for_click
    :   Wait for mouse click input before running the operator from a menu

        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