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

assistant: # NodeSocketFloatPercentage(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatPercentage(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Options to control global audio settings.
To control how sounds is played back from within Blender, see the audio settings
in the [Preferences](../../editors/preferences/system.html#prefs-system-sound).

Volume
:   Volume for the scene.

Distance Model
:   Changes how the sound attenuation is calculated based on the distance.
    Most physically correct is the *Inverse* model,
    but it’s also possible to choose a linear and an exponential falloff.
    The clamped modes limit the volume to be lower than 100% (1.0),
    that means if the distance is smaller than the reference distance, the volume is always 100%.
    For an exact description of each option
    see the [OpenAL documentation](https://www.openal.org/documentation/).

Doppler Speed
:   Speed of the sound for the Doppler effect calculations.
    The typical value is 343.3 m/s in air, in water for example this value is around 1560 m/s.

Doppler Factor
:   Controls how strong the Doppler effect is.
    You can exaggerate or attenuate the change of pitch, but physically correct is a factor of 1.0.

Update Animation Cache
:   Updates the audio animation cache. This is useful if you start noticing artifact in the audio.
user: Provide the full official documentation entry for Animation, preserving all code examples.

assistant: The most common trick is to
[Keyframe](../../glossary/index.xhtml#term-Keyframe) animate the location or rotation of an *Active* physics object as well as
the *Animated* checkbox.
When the curve on the *Animated* property switches to disabled, the physics engine takes over
using the object’s last known location, rotation and velocities.

Animating the strengths of various other parameters
(a [Motor’s](constraints/types/motor.xhtml) Target Velocity,
a [Hinge’s](constraints/types/hinge.xhtml) limits, etc.)
can be used to accomplish a wide variety of interesting results.

Enabling a constraint during the physics simulation often has dramatic results
as the physics engine tries to bring into alignment two objects which are often dramatically out of alignment.
It is very common for the affected objects to build up enough kinetic energy to bounce themselves out of camera.

Rigid body dynamics can be baked to normal keyframes with *Bake To Keyframes*
in the Object ‣ Rigid Body menu.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Shadow Effect samples.

|  |  |  |
| --- | --- | --- |
| <../../_images/grease-pencil_visual-effects_shadow_simple.png>   Simple Shadow. | <../../_images/grease-pencil_visual-effects_shadow_blur.png>   Blurred Shadow. | <../../_images/grease-pencil_visual-effects_shadow_stretch.png>   Stretched shadow with an empty as center of rotation. |
user: What is ShaderNodeVolumeCoefficients(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeVolumeCoefficients(ShaderNode)

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

*class* bpy.types.ShaderNodeVolumeCoefficients(*ShaderNode*)
:   Model all three physical processes in a volume, represented by their coefficients

    phase
    :   Phase function for the scattered light

        - `HENYEY_GREENSTEIN`
          Henyey-Greenstein – Henyey-Greenstein, default phase function for the scattering of light.
        - `FOURNIER_FORAND`
          Fournier-Forand – Fournier-Forand phase function, used for the scattering of light in underwater environments.
        - `DRAINE`
          Draine – Draine phase functions, mostly used for the scattering of light in interstellar dust.
        - `RAYLEIGH`
          Rayleigh – Rayleigh phase function, mostly used for particles smaller than the wavelength of light, such as scattering of sunlight in earth’s atmosphere.
        - `MIE`
          Mie – Approximation of Mie scattering in water droplets, used for scattering in clouds and fog.

        Type:
        :   enum in [`'HENYEY_GREENSTEIN'`, `'FOURNIER_FORAND'`, `'DRAINE'`, `'RAYLEIGH'`, `'MIE'`], default `'HENYEY_GREENSTEIN'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe FCurveSample(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FCurveSample(bpy_struct)

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

*class* bpy.types.FCurveSample(*bpy_struct*)
:   Sample point for F-Curve

    co
    :   Point coordinates

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

    select
    :   Selection status

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Allows copying and pasting images between Blender and the operating system’s clipboard.

Note, only PNG files are supported for direct clipboard copying and pasting.

Platform specific behavior:

- Windows: Supports pasting images by copying the image’s file path. This method allows all supported image formats.
- Linux: Requires Wayland for clipboard image support.
user: Describe Baking from the Blender manual or Python API, including usage steps and snippets.

assistant: # Baking

Baking allows saving and loading intermediate geometries.
Baking parts of the node tree can be used for better performance.

The data format used to store geometry data is not considered to be an import/export format.
Volume objects, however, are saved using the OpenVDB file format which can be used interoperably.

Data can be baked using two methods:

- [Bake Node](geometry/operations/bake.xhtml) – used to bake any portion of the node tree.
- [Simulation Zone Baking](simulation/simulation_zone.xhtml#geometry-nodes-simulation-baking) –
  used to bake animations where the result of one geometry state can influence the next state.

Data is not stored to disk until the [Bake](#bpy-ops-object-geometry-node-bake-single) operation is ran.
user: How do I use Select Similar in Blender? Include parameters, examples, warnings and best practices.

assistant: Children
:   Extends the selection to all hierarchical descendant bones.

Immediate Children
:   Extends the selection to all direct child bones.

Siblings
:   Selects bones that have the same parent as the active bone.

Length
:   Selects bones with a similar [bone length](properties/transform.xhtml#bpy-types-editbone-length) under the specified *Threshold*.

Direction (Y axis)
:   Select bones aligned on the Y axis (along the bone’s length).

Prefix
:   Select bones with matching name prefix (separated by `.`).

Suffix
:   Select bones with matching name suffix (separated by `.`).

Bone Collection
:   Select bones that share one or more bone collections with the active bone.

Color
:   Select bones that have the same color as the active bone.

Shape
:   Select bones using the same shape object (in Pose Mode).
user: Explain NodeTreeInterfaceSocketVector2D(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [-inf, inf], default (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: Explain Limited Dissolve in complete detail according to the official Blender documentation.

assistant: This tool can simplify your mesh by dissolving vertices and edges separating flat regions.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_delete_limited-dissolve-before.png>   Original mesh. | <../../../../_images/modeling_meshes_editing_mesh_delete_limited-dissolve-after.png>   Result of Limited Dissolve. |

Max Angle
:   Reduces detail on planar faces and linear edges with an adjustable angle threshold.

All Boundaries
:   Always dissolve vertices that have two edge users at boundaries.

Delimit
:   Prevent faces from joining when they don’t share certain properties (material for e.g.).
user: What is KeyingSet(bpy_struct) and how is it used in Blender Python scripting?

assistant: # KeyingSet(bpy_struct)

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

*class* bpy.types.KeyingSet(*bpy_struct*)
:   Settings that should be keyframed together

    bl_description
    :   A short description of the keying set

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

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

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

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

    is_path_absolute
    :   Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)

        Type:
        :   boolean, default False, (readonly)

    paths
    :   Keying Set Paths to define settings that get keyframed together

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

    type_info
    :   Callback function defines for built-in Keying Sets

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

    use_insertkey_needed
    :   Only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_needed
    :   Override default setting to only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_visual
    :   Override default setting to insert keyframes based on ‘visual transforms’

        Type:
        :   boolean, default False

    use_insertkey_visual
    :   Insert keyframes based on ‘visual transforms’

        Type:
        :   boolean, default False

    refresh()
    :   Refresh Keying Set to ensure that it is valid for the current context (call before each use of one)

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

assistant: # GeometryNodeRealizeInstances(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.GeometryNodeRealizeInstances(*GeometryNode*)
:   Convert instances into real geometry data

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Hello World Text Example, preserving all code examples.

assistant: Example of using the blf module. For this module to work we
need to use the GPU module [`gpu`](gpu.html#module-gpu "gpu") as well.

```
# Import stand alone modules.
import blf
import bpy

font_info = {
    "font_id": 0,
    "handler": None,
}

def init():
    """init function - runs once"""
    import os
    # Create a new font object, use external TTF file.
    font_path = bpy.path.abspath('//Zeyada.ttf')
    # Store the font index - to use later.
    if os.path.exists(font_path):
        font_info["font_id"] = blf.load(font_path)
    else:
        # Default font.
        font_info["font_id"] = 0

    # Set the font drawing routine to run every frame.
    font_info["handler"] = bpy.types.SpaceView3D.draw_handler_add(
        draw_callback_px, (None, None), 'WINDOW', 'POST_PIXEL')

def draw_callback_px(self, context):
    """Draw on the viewports"""
    # BLF drawing routine.
    font_id = font_info["font_id"]
    blf.position(font_id, 2, 80, 0)
    blf.size(font_id, 50.0)
    blf.draw(font_id, "Hello World")

if __name__ == '__main__':
    init()
```
user: Provide the full official documentation entry for Animation, preserving all code examples.

assistant: Animation is making an object move or change shape over time.
Objects can be animated in many ways:

Moving as a whole object
:   Changing their position, orientation or size in time;

Deforming them
:   Animating their vertices or control points;

Inherited animation
:   Causing the object to move based on the movement of another object (e.g. its parent, hook, armature, etc.).

In this chapter, we will cover the first two,
but the basics given here are actually vital for understanding the following chapters as well.

Animation is typically achieved with the use of [keyframes](keyframes/introduction.xhtml).

### State Colors

[image reference removed]

State colors of properties.

Properties have different colors and menu items for different states.

|  |  |
| --- | --- |
| Gray | Not animated |
| Yellow | Keyframed on the current frame |
| Green | Keyframed on a different frame |
| Orange | Changed from the keyframed value |
| Purple | Controlled by a driver |

The changed value highlight currently doesn’t work with [NLA](../editors/nla/introduction.xhtml).
user: What is GeometryNodeGridLaplacian(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeGridLaplacian(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.GeometryNodeGridLaplacian(*GeometryNode*)
:   Compute the divergence of the gradient of the input grid

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Domain
:   Which [attribute domain](../attributes_reference.xhtml#attribute-domains) to process.

Inspection Index
:   Geometry element index that is used by inspection features like the [Viewer Node](../output/viewer.xhtml)
    or [socket inspection](../inspection.xhtml).
user: Give a detailed overview of HueCorrectModifier(StripModifier): syntax, arguments, return values, common patterns.

assistant: # HueCorrectModifier(StripModifier)

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

*class* bpy.types.HueCorrectModifier(*StripModifier*)
:   Hue correction modifier for sequence strip

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

    open_mask_input_panel
    :   Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Rip Vertices and Extend from the Blender manual or Python API, including usage steps and snippets.

assistant: # Rip Vertices and Extend

This tool takes any number of selected vertices and duplicate-drags them along the closest edge to the mouse.
When extending an edge loop, it extends the vertices at the endpoints of the loop.
The behavior is similar to the *Extrude* tool, but it creates an n-gon.

It helps to easily add details to existing edges.
user: Show practical ways to work with Proportional Falloff Items in a Blender add-on or script – include code.

assistant: # Proportional Falloff Items

SMOOTH:
:   Smooth.

    Smooth falloff.

SPHERE:
:   Sphere.

    Spherical falloff.

ROOT:
:   Root.

    Root falloff.

INVERSE_SQUARE:
:   Inverse Square.

    Inverse Square falloff.

SHARP:
:   Sharp.

    Sharp falloff.

LINEAR:
:   Linear.

    Linear falloff.

CONSTANT:
:   Constant.

    Constant falloff.

RANDOM:
:   Random.

    Random falloff.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Geometry Nodes is a system for modifying the geometry of an object with node-based operations.
It can be accessed by adding a [Geometry Nodes Modifier](../modifiers/geometry_nodes.xhtml)
and setting up the nodes in the [Geometry Node Editor](../../editors/geometry_node.xhtml).

[image reference removed]

The properties of a Geometry Nodes modifier in the modifier stack.

The geometry node tree connected to a modifier is a [Node Group](../../interface/controls/nodes/groups.xhtml).
The geometry from the state before the modifier (the original geometry or the result of the previous
modifier) will be passed to the *Group Input* node. Then the node group can operate on the geometry
and pass an output to the *Group Output* node, where it will be passed to the next modifier.

Geometry nodes can modify different types of geometry:

- [Meshes](../meshes/introduction.xhtml)
- [Curves](../curves/introduction.xhtml)
- [Point Clouds](../point_cloud/index.xhtml)
- [Volumes](../volumes/introduction.xhtml)
- [Instances](instances.xhtml)

The interface of the modifier is described in the
[Modifier](../modifiers/geometry_nodes.xhtml) page.

To expand Blender with node-group operators, see the [Node-Based Tools](tools.xhtml) page.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

Pinch
:   Adds a consistent pinching effect to your stroke.
    If set to 0 it the brush will behave like the
    [Draw](draw.xhtml) brush.
    If set to 1 and the brush strength set to 0, the brush
    will behave like a [Pinch](pinch.xhtml) brush.
user: Describe Directory Layout from the Blender manual or Python API, including usage steps and snippets.

assistant: Sections should be generally structured as follows:

- `directory_name/`

  - `index.rst` (contains links to internal files)
  - `introduction.rst`
  - `section_1.rst`
  - `section_2.rst`

For example:

- `rendering/`

  - `index.rst`
  - `cycles/`

    - `index.rst`
    - `introduction.rst`
    - `materials/`

      - `index.rst`
      - `introduction.rst`
      - `volumes.rst`

The idea is to enclose all the content of a section inside of a folder. Ideally every section should have an
`index.rst` (containing the TOC for that section) and an `introduction.rst` (introducing) to the contents of the
section.

### Table of Contents

By default, a table of contents should show two levels of depth:

```
.. toctree::
   :maxdepth: 2

   introduction.rst
   perspective.rst
   depth_of_field.rst
```
user: Explain PoseBoneConstraints(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # PoseBoneConstraints(bpy_struct)

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

*class* bpy.types.PoseBoneConstraints(*bpy_struct*)
:   Collection of pose bone constraints

    active
    :   Active PoseChannel constraint

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

    new(*type*)
    :   Add a constraint to this object

        Parameters:
        :   **type** (enum in [Constraint Type Items](bpy_types_enum_items/constraint_type_items.html#rna-enum-constraint-type-items)) – Constraint type to add

        Returns:
        :   New constraint

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

    remove(*constraint*)
    :   Remove a constraint from this object

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Removed constraint

    move(*from_index*, *to_index*)
    :   Move a constraint to a different position

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

    copy(*constraint*)
    :   Add a new constraint that is a copy of the given one

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Constraint to copy - may belong to a different object

        Returns:
        :   New constraint

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

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

assistant: # Subdivision

These settings are used to control [Adaptive Subdivision](../../../modeling/modifiers/generate/subdivision_surface.xhtml#modifiers-generate-subsurf-adaptive-subdivision).

Dicing Rate Render, Viewport
:   Multiplier for the size of [Micropolygons](../../../glossary/index.xhtml#term-Micropolygons) for the final/viewport render.

Offscreen Scale
:   Multiplier for dicing rate of geometry outside of the camera view.
    The dicing rate of objects is gradually increased the further they are outside the camera view.
    Lower values provide higher quality reflections and shadows for off screen objects,
    while higher values use less memory.

Max Subdivisions
:   Stop subdividing when this level is reached even if the dicing rate would produce finer [Tessellation](../../../glossary/index.xhtml#term-Tessellation).

Dicing Camera
:   Camera to use as reference point when subdividing geometry,
    useful to avoid crawling artifacts in animations when the scene camera is moving.
user: Describe Face Area Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Face Area Node

[image reference removed]

The *Face Area* node outputs the surface area of a mesh’s faces.
The units are in Blender units no matter the unit system,
equivalent to meters-squared at the default unit scale.
user: What is Adding Properties to a Keying Set and how is it used in Blender Python scripting?

assistant: Some ways to add properties to Keying Sets.

`RMB` the property in the *User Interface*, then select *Add Single to Keying Set* or *Add All to Keying Set*.
This will add the properties to the active Keying Set, or to a new Keying Set if none exist.

Hover the mouse over the properties, then press `K`, to add *Add All to Keying Set*.
user: How do I use Texture Preview in Blender? Include parameters, examples, warnings and best practices.

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

To do this, set up side-by-side areas, one Area in 3D Viewport set to *Texture* shading option,
and in the second Area the Image Editor loaded with your image.
Position the 3D Viewport to show the object that is UV-mapped to the loaded image.
In the image to the right, the texture being painted is mapped to the “Normal” attribute,
and is called “bump mapping”, where the grayscale image is used to make the flat surface appear bumpy.
See Texture Mapping Output for more information on bump mapping.
user: How do I use Push/Pull in Blender? Include parameters, examples, warnings and best practices.

assistant: # Push/Pull

[image reference removed]

Push/Pull distance.

Moves the selected elements closer to (Push) or further away from (Pull) the pivot point,
all by the same distance. You can control this distance by moving the mouse up or down,
typing a number, or using the slider in the [Adjust Last Operation](../../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
user: Describe ShaderNodeHoldout(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeHoldout(ShaderNode)

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

*class* bpy.types.ShaderNodeHoldout(*ShaderNode*)
:   Create a “hole” in the image with zero alpha transparency, which is useful for compositing.
    Note: the holdout shader can only create alpha when transparency is enabled in the film settings

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Using Cloth for Soft Bodies, preserving all code examples.

assistant: [image reference removed]

Using cloth for soft bodies.

Cloth can also be used to simulate soft bodies.
It is for sure not its main purpose but it works nonetheless.
The example image uses standard *Rubber* material, no fancy settings,
just `Alt`-`A`.

Blend-file for the example image:
[Using Cloth for soft bodies](https://archive.blender.org/wiki/2015/index.php/File:Cloth-sb1.blend).
user: Describe Object Mode from the Blender manual or Python API, including usage steps and snippets.

assistant: Proportional Editing is typically used in *Edit Mode*, but it can also be used in *Object Mode*.
The tool then works on entire objects rather than individual mesh components.

In the image below, the leftmost cylinder is being scaled up vertically,
which also affects the cylinders near it.

[image reference removed]

Proportional Editing in Object Mode.
user: What is Set Selection Node and how is it used in Blender Python scripting?

assistant: # Set Selection Node

[image reference removed]

The *Set Selection* node controls which geometry is [selected](../../../../interface/selecting.html).

The input node for this data is the [Selection Node](../read/selection.html).
user: Describe GeometryNodeRepeatInput(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeRepeatInput(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.GeometryNodeRepeatInput(*GeometryNode*)
:   paired_output
    :   Zone output node that this input node is paired with

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

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

    pair_with_output(*output_node*)
    :   Pair a zone input node with an output node.

        Parameters:
        :   **output_node** ([`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal")) – Output Node, Zone output node to pair with

        Returns:
        :   Result, True if pairing the node was successful

        Return type:
        :   boolean

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

assistant: [image reference removed]

Anywhere the geometry is a curve, this node can be used to generate a selection of
only the first and last points of each spline. Here, the *Points* input of
the [Instance on Points Node](../../instances/instance_on_points.xhtml) is a curve
consisting of the poly spline shown in Edit Mode.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Vector
:   Vector of the input system that is to be divided into radial segments.

Sides
:   Number of radial segments to divide the input coordinate system into.
    A non-integer value results in an irregular segment that is smaller than the regular segments.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_0.png   Sides: 5.0. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_25.png   Sides: 5.25. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_5.png   Sides: 5.5. | ../../../../_images/render_shader-nodes_radial_tiling_segments-6_0.png   Sides: 6.0. |

Roundness
:   Roundness of the segment coordinate systems.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_0.png   Roundness: 0.0. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_25.png   Roundness: 0.25. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_5.png   Roundness: 0.5. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-1_0.png   Roundness: 1.0. |
user: What is Keyboard Shortcuts and how is it used in Blender Python scripting?

assistant: To quickly add a *Subdivision Surface* modifier to one or more objects, select the object(s) and press `Ctrl`-`1`.
That will add a Subdivision Surface modifier with *Viewport* subdivisions set to 1.
You can use other numbers too, such as `Ctrl`-`2`, `Ctrl`-`3`, etc,
to add a modifier with that number of subdivisions.
Adding a *Subdivision Surface* modifier in this fashion will not modify the *Render* subdivisions.

If an object already has a *Subdivision Surface* modifier,
doing this will simply change its subdivision level instead of adding another modifier.
user: Explain Set Curve Tilt Node in complete detail according to the official Blender documentation.

assistant: # Set Curve Tilt Node

[image reference removed]

The *Set Curve Tilt* controls the tilt angle at each curve control point.
That angle rotates normal vector which is generated at each point
when evaluating the curve. The normal then can be retrieved with
the [Normal Node](../../geometry/read/normal.xhtml).

The rotation of the normal vector is an [Axis Angle](../../../../glossary/index.xhtml#term-Axis-Angle) rotation.
It is the same as the [Vector Rotate Node](../../utilities/vector/vector_rotate.xhtml) operation
with the tangent vector as the axis, the raw evaluated normal is used as
the original vector, and the tilt as the rotation angle.

The input node for this data is the [Curve Tilt Node](../read/curve_tilt.xhtml).
user: Show practical ways to work with Color Management in a Blender add-on or script – include code.

assistant: This panel controls how [Color Management](../../color_management/index.xhtml) is applied when saving images.

Follow Scene:
:   Uses the same color management settings defined by the active Scene.
    These properties are defined in the Render Settings

Override:
:   Uses custom color management settings defined by the properties below in the panel;
    disregarding any color management settings set at the Scene level.

For a detailed description of color management properties,
see the [Color Management](../../color_management/displays_views.xhtml#render-post-color-management) page.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.active_pose_bone`](bpy.context.html#bpy.context.active_pose_bone "bpy.context.active_pose_bone") - [`bpy.context.pose_bone`](bpy.context.html#bpy.context.pose_bone "bpy.context.pose_bone") - [`bpy.context.selected_pose_bones`](bpy.context.html#bpy.context.selected_pose_bones "bpy.context.selected_pose_bones") - [`bpy.context.selected_pose_bones_from_active_object`](bpy.context.html#bpy.context.selected_pose_bones_from_active_object "bpy.context.selected_pose_bones_from_active_object") - [`bpy.context.visible_pose_bones`](bpy.context.html#bpy.context.visible_pose_bones "bpy.context.visible_pose_bones") - [`Object.convert_space`](bpy.types.Object.html#bpy.types.Object.convert_space "bpy.types.Object.convert_space") | - [`Pose.bones`](bpy.types.Pose.html#bpy.types.Pose.bones "bpy.types.Pose.bones") - [`PoseBone.bbone_custom_handle_end`](#bpy.types.PoseBone.bbone_custom_handle_end "bpy.types.PoseBone.bbone_custom_handle_end") - [`PoseBone.bbone_custom_handle_start`](#bpy.types.PoseBone.bbone_custom_handle_start "bpy.types.PoseBone.bbone_custom_handle_start") - [`PoseBone.child`](#bpy.types.PoseBone.child "bpy.types.PoseBone.child") - [`PoseBone.custom_shape_transform`](#bpy.types.PoseBone.custom_shape_transform "bpy.types.PoseBone.custom_shape_transform") - [`PoseBone.parent`](#bpy.types.PoseBone.parent "bpy.types.PoseBone.parent") |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Transition
:   The type of transition used.

    Single
    :   Reveals the next strip by uncovering it in a straight line moving across the image.

    Double
    :   Similar to *Single*, but uses two lines either starting from the middle of the image or the outside.
        Like the blink of an eye.

    Iris
    :   Reveals the next strip through an expanding (or contracting) circle.
        Like the aperture of a camera or pupil of an eye.
        You can blur the transition, so it looks like ink bleeding through a paper.

    Clock
    :   Like the hands of an analog clock, it sweeps clockwise or (if Wipe In is enabled)
        counterclockwise from the 9:00 position. As it sweeps, it reveals the next strip.

Direction
:   Controls whether to fade *In* or *Out*.

Blur Width
:   The width of the blur used to blur the transition.

Angle
:   Controls the angle of the line for *Single* and *Double* transition types.

Default Fade
:   Automatically calculates a linear fade over the length of the strip.

    Effect Fader
    :   Allows you to manually [keyframe](../../../../../animation/keyframes/index.xhtml) a custom fade.
        This can be used with different [easings](../../../../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-easing)
        to fine-tune the fade in/out.