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

assistant: # BlendDataWindowManagers(bpy_struct)

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

*class* bpy.types.BlendDataWindowManagers(*bpy_struct*)
:   Collection of window managers

    tag(*value*)
    :   tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # BlendImportContextItems(bpy_struct)

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

*class* bpy.types.BlendImportContextItems(*bpy_struct*)
:   Collection of blendfile import context items

    *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 Inputs and how is it used in Blender Python scripting?

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

Factor
:   Controls the overall strength of the rolling effect.
    A value of 0.0 disables the effect, while 1.0 applies the full roll.

Subdivision
:   Defines how finely each curve is subdivided before deformation.
    Higher values produce smoother and more detailed rolls but increase computational cost.

Variation Level
:   Introduces variation along the roll path by smoothing or distorting its shape.
    Higher values produce more natural and uneven rolls.

Roll Length
:   Specifies the portion of each curve (measured from the tip) that is rolled.
    Increasing this value extends the length of the coiled section.

Roll Radius
:   Determines the radius of the roll, controlling how tightly each curve is coiled.

Roll Depth
:   Adds an offset along the roll axis, producing a stretched or compressed spiral shape.

Roll Taper
:   Controls how the roll radius decreases toward the tip, tapering the spiral.

Retain Overall Shape
:   When enabled, offsets the roll along the curve’s original path to better preserve the initial flow and shape
    of the hair.

Roll Direction
:   Defines the axis around which the roll is performed (e.g., X, Y, or Z).
    This determines the orientation of the curls.

Random Orientation
:   Introduces randomization to the direction of the roll, helping to avoid uniform patterns
    and adding a more natural appearance.

Seed
:   Sets the random seed for the orientation randomization.
    Changing the value alters the distribution of curl directions while keeping the same parameters.

Preserve Length
:   When enabled, maintains the total length of each curve after deformation.
    When disabled, the curves may stretch or compress slightly as a result of rolling.
user: Describe Window Options from the Blender manual or Python API, including usage steps and snippets.

assistant: `-w`, `--window-border`
:   Force opening with borders.

`-W`, `--window-fullscreen`
:   Force opening in full-screen mode.

`-p`, `--window-geometry` `<sx>` `<sy>` `<w>` `<h>`
:   Open with lower left corner at `<sx>`, `<sy>` and width and height as `<w>`, `<h>`.

`-M`, `--window-maximized`
:   Force opening maximized.

`-con`, `--start-console`
:   Start with the console window open (ignored if `-b` is set), (Windows only).

`--no-native-pixels`
:   Do not use native pixel size, for high resolution displays (MacBook `Retina`).

`--no-window-focus`
:   Open behind other windows and without taking focus.
user: Show practical ways to work with Limit Total Vertex Groups in a Blender add-on or script – include code.

assistant: Reduce the number of weight groups per vertex to the specified Limit.
The tool removes lowest weights first until the limit is reached.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](../../../sculpt_paint/weight_paint/editing.html#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   Maximum number of weights allowed on each vertex.
user: Give a detailed overview of No Physics: syntax, arguments, return values, common patterns.

assistant: The particles will be given no motion, which makes them belong to no physics system.
At first a physics type that makes the particles to be static could seem a bit strange,
but it can be very useful at times.
None physics make the particles stick to their emitter their whole life time. The initial
velocities here are for example used to give a velocity to particles that are affected
by a harmonic effector with this physics type when the effect of the effector ends.

Moreover, it can be very convenient to have particles at disposal
(whose both Unborn and Died are visible on render)
to groom vegetation and/or ecosystems using *Object* or *Group* types of visualization.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: Closures define reusable logic that can be injected into another node tree. They are commonly used in procedural systems
where part of the behavior should remain user-defined.

Typical use cases include:

- Defining a custom scattering rule for a terrain generator.
- Describing how to distribute or modify instances procedurally.
- Providing adjustable mappings, field evaluations, or transformation logic.

### Using External Values

Closures can *capture* values from outside their zone. A captured value is stored as part of the closure definition and
remains available even when the closure is evaluated in a different context.

Captured values make it possible to preserve external parameters—such as scale, density, or color—without creating
explicit input sockets. This makes closures cleaner and easier to reuse in different node trees.

[image reference removed]

Capturing an external input value inside a closure.

### Example

1. In a terrain generator node group, replace the tree distribution logic with an
   [Evaluate Closure](evaluate_closure.html) node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, create a *Closure Zone* and connect it to that input.
4. Inside the closure zone, define the desired tree placement logic.

When the generator evaluates the closure, the custom distribution defined in the zone is executed instead of the
default behavior.

[image reference removed]

A *Closure Zone* defining a custom distribution pattern for tree scattering.
user: Give a detailed overview of NodeTreeInterfaceSocketVectorDirection4D(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

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

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### General

### Unique

Deformation
:   Deformation type that is used by the brush.

    Bend:
    :   Rotates the boundary around the local Y axis.
        Useful for creating folding shapes, like sleeves.

    Expand:
    :   Moves/extends the mesh boundary in the local X direction.
        Useful for extending the boundaries along the surface.

    Inflate:
    :   Works similar to the [Inflate](inflate.xhtml) tool but,
        the vertices that are inflated are constrained to the mesh boundary.

    Grab:
    :   Works similar to the [Grab](grab.xhtml) tool but,
        the vertices that are grabbed are constrained to the mesh boundary.

    Twist:
    :   Rotates the active boundary around the local Z axis.
        Useful for creating folds like on a skirt.

    Smooth:
    :   Works similar to the [Grab](smooth.xhtml) tool but,
        the vertices that are smoothed are constrained to the mesh boundary.

Boundary Falloff
:   How the brush [Falloff](../../brush/falloff.xhtml) is applied across the boundary.

    Constant:
    :   Applies the same deformation in the entire boundary.

    Brush Radius:
    :   Applies the deformation only within the brush radius.

    Loop:
    :   Applies the brush falloff in a loop pattern along the boundary.

    Loop and Invert:
    :   Applies the falloff radius in a loop pattern,
        inverting the direction back & forth.

Boundary Origin Offset
:   Offset of the boundary origin in relation to the brush radius.
user: Provide the full official documentation entry for Miscellaneous, preserving all code examples.

assistant: Sculpt Overlay Color
:   Defines a color to be used in the inner part of
    the brushes circle when in Sculpt Mode, and it is placed as an overlay to the brush,
    representing the focal point of the brush influence.
    The overlay color is visible only when the overlay visibility is selected
    (clicking at the *eye* to set its visibility), and the transparency of the overlay is
    controlled by the alpha slider located at the Tool tab ‣ Display panel in the Sidebar.
user: What is In Object Mode and how is it used in Blender Python scripting?

assistant: The pivot point becomes the center of the bounding box *around the selected objects’
origin points*, not their geometry.

This means that, if you have a single object selected, the pivot point is the same
as the object’s [origin point](../../../../scene_layout/object/origin.html) – which can be customized
and doesn’t have to be in the center. In the example below, the orange rectangle
has it in a corner instead.

[image reference removed]

Single object rotation.

If you have multiple objects selected, the pivot point becomes the center
of an imaginary box around their origins.

The image below shows the difference between Bounding Box Center
and [Median Point](median_point.html).
The latter calculates the average position of the origins,
meaning that the pivot point shifts towards the area with the most objects.

[image reference removed]

Difference between “Bounding Box Center” (left) and “Median Point” (right).
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Face Count
:   The number of faces that use the edge as one of their sides.
    When the value is one, the edge is a [non-manifold](../../../../glossary/index.xhtml#term-Non-manifold) boundary edge.
    Alternatively, when the value is zero, the edge is a loose edge, not used by any faces.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: 1. Select the desired keyframes to draw, edit or sculpt at the same time.
2. Activate the Multiframe tool in the 3D Viewport’s header with the toggle button (faded lines icon).
3. Once activated you can:

   - Select the points in all the selected keyframes and make your edits.
   - Start sculpting. The sculpt brushes will affects all the strokes in the selected keyframes.
   - Start weight painting. The weight paint brush will affect all the strokes in the selected keyframes.
   - Start Drawing. The new strokes will be added in all the selected keyframes.
     If you are using the Fill tool then it will be applied in all the selected keyframes.
   - When interpolating you can select the stroke from the different frames in the right order.
     Interpolate tool will use the selection order to calculate the correct stroke pairs.
user: What is Smooth Geometry Node and how is it used in Blender Python scripting?

assistant: # Smooth Geometry Node

[image reference removed]

The *Smooth Geometry* node smooths connected parts of a geometry by averaging the positions
of neighboring elements. It can be used to reduce surface irregularities or create a
softened, more organic appearance without significantly altering the overall shape.
user: Explain GeometryNodeCurveQuadraticBezier(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeCurveQuadraticBezier(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.GeometryNodeCurveQuadraticBezier(*GeometryNode*)
:   Generate a poly spline in a parabola shape with control points positions

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

assistant: The calculation done by the *Smooth* modifier is a simple and logical one,
and can be thought of as the geometric equivalent of blurring images.

Each new vertex position is simply moved towards the average position of all its neighbor vertices
(topologically speaking, i.e. the vertices directly connected to it by an edge).
user: Explain Attribute Domain Only Mesh Items in complete detail according to the official Blender documentation.

assistant: # Attribute Domain Only Mesh Items

POINT:
:   Point.

    Attribute on point.

EDGE:
:   Edge.

    Attribute on mesh edge.

FACE:
:   Face.

    Attribute on mesh faces.

CORNER:
:   Face Corner.

    Attribute on mesh face corner.
user: Give a detailed overview of Bpy.Types.Greasepencilhookmodifier: syntax, arguments, return values, common patterns.

assistant: ier.invert_vertex_group GreasePencilHookModifier.layer_pass_filter GreasePencilHookModifier.material_filter GreasePencilHookModifier.material_pass_filter GreasePencilHookModifier.matrix_inverse GreasePencilHookModifier.object GreasePencilHookModifier.open_falloff_panel GreasePencilHookModifier.open_influence_panel GreasePencilHookModifier.strength GreasePencilHookModifier.subtarget GreasePencilHookModifier.tree_node_filter GreasePencilHookModifier.use_custom_curve GreasePencilHookModifier.use_falloff_uniform GreasePencilHookModifier.use_layer_group_filter GreasePencilHookModifier.use_layer_pass_filter GreasePencilHookModifier.use_material_pass_filter GreasePencilHookModifier.vertex_group_name GreasePencilHookModifier.bl_rna_get_subclass() GreasePencilHookModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Emission in a Blender add-on or script – include code.

assistant: # Emission

[image reference removed]

The *Emission* node is used to add Lambertian emission shader.
This can for example, be used for material and light surface outputs.

Light strength for point, spot and area lights is specified in Watts.

Sun lights are specified in Watts/m2, which require much smaller values like 1 W/m2.
This can be confusing, but specifying strength in Watts would not have been convenient;
the real sun for example has strength 384.6×1024W.
Emission shaders on meshes are also in Watts/m2.
user: Provide the full official documentation entry for Alpha Over Node, preserving all code examples.

assistant: # Alpha Over Node

[image reference removed]

The *Alpha Over* node composites two images by layering the *Foreground* image over the *Background*,
using standard alpha blending operations.

This node is commonly used to combine rendered elements, overlays, or visual effects in a single image,
such as placing text, logos, or transparent effects over footage.
user: Describe LineStyleAlphaModifier_Noise(LineStyleAlphaModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleAlphaModifier_Noise(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_Noise(*LineStyleAlphaModifier*)
:   Alpha transparency based on random noise

    amplitude
    :   Amplitude of the noise

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

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    period
    :   Period of the noise

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

    seed
    :   Seed for the noise generation

        Type:
        :   int in [1, 32767], default 0

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleAlphaModifier_Noise.type "bpy.types.LineStyleAlphaModifier_Noise.type")
user: What is Supported Video & Audio Formats and how is it used in Blender Python scripting?

assistant: # Supported Video & Audio Formats

Blender used [FFmpeg](https://ffmpeg.org/) to handle video encoding/decoding various video formats.
These formats are primarily used for compressing rendered sequences into a playable movie.
Video formats are composed of a container, a codec, and sometimes audio which is stored using its own codec.
The roll of the container to encapsulate video and audio data that is compressed using a codec.

Codecs compress the channels of a video down to save space and enable continuous playback.
*Lossy* codecs make smaller files at the expense of image quality,
while *lossless* codecs compress as much as possible the video/audio, but without losing any existing data.

Some codecs, like H.264, are great for larger images. Codecs are used to encode and decode the movie,
and so must be present on both the encoding machine (Blender) and the target machine.
The results of the encoding are stored in a container file.

There are dozens, if not hundreds, of codecs, including Xvid, H.264, DivX, Microsoft,
and so on. Each has advantages and disadvantages, and compatibility with different players on
different operating systems.
user: Provide the full official documentation entry for Expression, preserving all code examples.

assistant: This is a quick way to add drivers with a scripted expression.
First click the property you want to add a driver to, then type a hash `#` and a scripted expression.

Some examples:

- `#frame`
- `#frame / 20.0`
- `#sin(frame)`
- `#cos(frame)`
user: Show practical ways to work with Bpy.Types.Nodetreeinterfacesocketvectordirection in a Blender add-on or script – include code.

assistant: rties Inherited Functions
user: What is Select Edge Rings and how is it used in Blender Python scripting?

assistant: In *Edge* select mode, holding `Ctrl`-`Alt`
while selecting an edge (or two vertices) selects a sequence of edges that are not connected,
but on opposite sides to each other continuing along a [face loop](../structure.xhtml).

As with edge loops, you can also select edge rings based on current selection,
using either Select ‣ Select Loops ‣ Edge Rings.

[image reference removed]

A selected edge loop, and a selected edge ring.

In Fig. [A selected edge loop, and a selected edge ring.](#fig-mesh-select-advanced-loop-ring) the same edge was clicked on,
but two different “groups of edges” were selected, based on the different tools.
One is based on edges during computation and the other is based on faces.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: Pixelate Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_pixelate_size-0.png   Original image. | ../../_images/grease-pencil_visual-effects_pixelate_size-20.png   Size: 20 px. | ../../_images/grease-pencil_visual-effects_pixelate_size-100.png   Size: 100 px. | ../../_images/grease-pencil_visual-effects_pixelate_size-200.png   Size: 200 px. |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Image
:   Standard color input.

Brightness
:   An additive-type factor by which to increase the overall brightness
    of the image. Use a negative number to darken an image.

Contrast
:   A scaling type factor by which to make brighter pixels brighter, but keeping the darker pixels dark.
    Higher values make details stand out. Use a negative number to decrease the overall contrast in the image.
user: What is Uilist Operators and how is it used in Blender Python scripting?

assistant: # Uilist Operators

bpy.ops.uilist.entry_add(*\**, *list_path=''*, *active_index_path=''*)
:   Add an entry to the list after the current active item

    Parameters:
    :   - **list_path** (*string**,* *(**optional**,* *never None**)*) – list_path
        - **active_index_path** (*string**,* *(**optional**,* *never None**)*) – active_index_path

    File:
    :   [startup/bl_ui/generic_ui_list.py:210](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_ui/generic_ui_list.py#L210)

bpy.ops.uilist.entry_move(*\**, *list_path=''*, *active_index_path=''*, *direction='UP'*)
:   Move an entry in the list up or down

    Parameters:
    :   - **list_path** (*string**,* *(**optional**,* *never None**)*) – list_path
        - **active_index_path** (*string**,* *(**optional**,* *never None**)*) – active_index_path
        - **direction** (enum in [`'UP'`, `'DOWN'`], (optional)) –

          Direction

          - `UP`
            UP – UP.
          - `DOWN`
            DOWN – DOWN.

    File:
    :   [startup/bl_ui/generic_ui_list.py:238](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_ui/generic_ui_list.py#L238)

bpy.ops.uilist.entry_remove(*\**, *list_path=''*, *active_index_path=''*)
:   Remove the selected entry from the list

    Parameters:
    :   - **list_path** (*string**,* *(**optional**,* *never None**)*) – list_path
        - **active_index_path** (*string**,* *(**optional**,* *never None**)*) – active_index_path

    File:
    :   [startup/bl_ui/generic_ui_list.py:193](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_ui/generic_ui_list.py#L193)
user: Show practical ways to work with Mark/Clear Sharp in a Blender add-on or script – include code.

assistant: Signifies the selected edge(s) as being “sharp”.
This edge attribute can either be set (mark) or unset (clear).

This influences the rendering of [Normals](../../structure.xhtml#modeling-meshes-structure-normals)
to appear flat if smooth shading is enabled for the connecting face or object.
This attribute can also be used by many modifiers or operators to mask their effect.

Internally, this uses the [sharp edge attribute](../../../geometry_nodes/attributes_reference.xhtml#geometry-nodes-builtin-attributes).
user: Show practical ways to work with Drivers in a Blender add-on or script – include code.

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

On Windows, drivers are provided by the graphics card manufacturer (Intel). Windows Update automatically installs
graphics drivers, or your computer manufacturer may provide its own version of the graphics drivers.

However, these are not always the latest version or may have been corrupted in some way. We recommend always using
the official drivers.

[Download Latest Intel Drivers](https://www.intel.com/content/www/us/en/support/products/80939/graphics.html)
user: How do I use TextureNodeMixRGB(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeMixRGB(TextureNode)

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

*class* bpy.types.TextureNodeMixRGB(*TextureNode*)
:   blend_type
    :   Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    use_alpha
    :   Include alpha of second input in this operation

        Type:
        :   boolean, default False

    use_clamp
    :   Clamp result of the node to 0.0 to 1.0 range

        Type:
        :   boolean, default False

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

assistant: Projects each selected face onto the most suitable side of a virtual cube,
then places all these sides in the UV map, overlapping each other.
If you don’t want them to overlap, you can use [Pack Islands](../uv/editing.html#bpy-ops-uv-pack-islands).

The cube is centered on the [Transform Pivot Point](../../../editors/3dview/controls/pivot_point/index.html)
and aligned to the mesh’s local axes.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Cube Size
:   The size of the cube to project onto.

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.html), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.html).

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: Explain Rigid Body Cache in complete detail according to the official Blender documentation.

assistant: The *Cache* subpanel specifies the frame range in which the simulation is active.
Can be used to bake the simulation.

Start/End
:   First and last frame of the simulation.

Bake
:   Calculates the simulation and protects the cache. You need to be in *Object Mode* to bake.

Delete Bake
:   Active after the baking of simulation. Clears the baked cache.

Calculate to Frame
:   Bake physics to current frame.

Current Cache to Bake
:   Bake from Cache.

Bake All Dynamics
:   Bake all physics.

Delete All Bakes
:   Deletes all baked caches of all objects in the current scene.

Update All to Frame
:   Update cache to current frame.

If you have not saved the blend-file, the cache is created in memory,
so save your file first or the cache may be lost.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: ### Running Scripts

The most notable keystroke is `Alt`-`P` which executes the current text as a Python script.
You can access not just the standard Python modules, but also a whole bunch of Blender-specific ones;
see [Scripting & Extending Blender](../advanced/scripting/index.html).
user: Give a detailed overview of Dragging: syntax, arguments, return values, common patterns.

assistant: The following shortcuts can be used while moving/rotating/scaling an object in the 3D Viewport,
dragging the slider of a value, and so on. Note that they should be pressed after starting
the drag, not before.

|  |  |
| --- | --- |
| `Ctrl` | Snap to coarse increments, making it easier to (say) rotate an object by exactly 90°. |
| `Shift` | Make the value change more slowly in response to mouse movement, giving you more precision. |
| `Shift`-`Ctrl` | Snap to fine increments. |
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Quadratic
:   Quadratic light falloff; this will leave strength unmodified if smooth is 0.0 and corresponds to reality.

Linear
:   Linear light falloff, giving a slower decrease in intensity over distance.

Constant
:   Constant light falloff, where the distance to the light has no influence on its intensity.
user: Provide the full official documentation entry for Selecting Bone Joints, preserving all code examples.

assistant: To select bones’ joints you have the [standard selection](../../../scene_layout/object/selecting.html) methods.

### Inverse Selection

As stated above, you have to remember that these selection tools are for bones’ joints only,
not the bones’ bodies.

For example, the *Inverse* selection option `Ctrl`-`I`
inverts the selection of bones’ joints, not of bones (see *Inverse selection*).

Remember that a bone is selected only if both its joints are selected. So,
when the selection status of bones’ joints is inverted, a new set of bones is selected.

Inverse selection.

|  |  |
| --- | --- |
| <../../../_images/animation_armatures_bones_selecting_two-bones.png>   Two bones selected. | <../../../_images/animation_armatures_bones_selecting_three-ends.png>   The result of the inverse selection `Ctrl`-`I`: The bones joints selection has been inverted, and not the bones selection. |

### Selecting Connected Bone Joints

Another example is: when you select the root of a bone connected to its parent,
you also implicitly select the tip of its parent (and vice versa).
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be translated.

Translation
:   The vector to translate the instances by.

Local Space
:   If enabled, the instances are translated relative to their initial rotation.
    Otherwise they are translated in the local space of the modifier object.
user: What is Switch Direction and how is it used in Blender Python scripting?

assistant: # Switch Direction

This tool allows you to switch the direction of the selected bones
(i.e. their root will become their tip, and vice versa).

Switching the direction of a bone will generally break the chain(s) it belongs to.
However, if you switch a whole (part of a) chain, the switched bones will still be parented/connected,
but in “reversed order”. See the Fig. [Switching example.](#fig-rig-properties-switch).

Switching example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_switch-direction_example-1.png   An armature with one selected bone, and one selected chain of three bones, just before switching. | ../../../../_images/animation_armatures_bones_editing_switch-direction_example-2.png   The selected bones have been switched. Bone.005 is no more connected nor parented to anything. The chain of switched bones still exists, but reversed (now Bone.002 is its root, and Bone is its tip). Bone.003 is now a free bone. |
user: Explain Clean Vertex Group Weights in complete detail according to the official Blender documentation.

assistant: Clean Vertex Group Weights unassigns vertices from
[Vertex Groups](../../../modeling/meshes/properties/vertex_groups/index.xhtml)
whose weights are below the *Limit*. Removes weights below a given threshold.
This tool is useful for clearing your weight groups of very low (or zero) weights.

In the example shown, a cutoff value of 0.2 is used (see operator options below)
so all blue parts are cleaned out.

Note, the images use the *Show Zero weights* Active option
so that unreferenced Weights are shown in Black.

[image reference removed]

Clean example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](../../../sculpt_paint/weight_paint/editing.xhtml#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   This is the minimum weight value that will be kept in the group.
    Weights below this value will be removed from the group.

Keep Single
:   Ensure that the *Clean Vertex Group Weights* tool will not create completely unreferenced vertices
    (which are vertices that are not assigned to any vertex group), so each vertex will
    keep at least one weight, even if it is below the limit value!
user: Explain Keeping Pages Up To Date in complete detail according to the official Blender documentation.

assistant: When the manual is updated, those translations which are outdated will be marked as fuzzy. To keep track with that,
you can use a tool we created for that task, see [How to install it](contribute.xhtml#translations-fuzzy-strings).
user: Show practical ways to work with GeometryNodeSDFGridFillet(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeSDFGridFillet(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.GeometryNodeSDFGridFillet(*GeometryNode*)
:   Round off concave internal corners in a signed distance field. Only affects areas with negative principal curvature, creating smoother transitions between surfaces

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # NodeSocketFloatTimeAbsolute(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.NodeSocketFloatTimeAbsolute(*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: Give a detailed overview of Modifying a Pose Asset: syntax, arguments, return values, common patterns.

assistant: A pose asset can be modified after it has been created.
This is only possible for pose assets in the current file or that have been exported into
an .asset.blend file.
For that, an operator has been created which can be accessed by right clicking a pose asset.
That operator works on the active object, so updating the asset from selected bones
of multiple armatures won’t work. It will find the best matching slot, falling back to
the first one.
There are 4 modes.

Adjust Pose
:   Update existing channels in the pose asset from the selected bones,
    but don’t remove or add any channels.

Replace
:   Completely replace all channels in the pose asset with the channels of the selected bones.

Add
:   Add channels of the selected bones to the pose asset. Existing channels will be updated.

Remove
:   Remove channels of the selected bones from the pose asset.
user: How do I use ShaderNodeRadialTiling(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeRadialTiling(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.ShaderNodeRadialTiling(*ShaderNode*)
:   Transform Coordinate System for Radial Tiling

    normalize
    :   Normalize the X coordinate of the Segment Coordinates output to a [0, 1] interval and offset the Y coordinate into a [0, infinity) interval. When checked, the textures are stretched to fit into each angular segment. When not checked, the parts of the textures that don’t fit into each angular segment are cropped

        Type:
        :   boolean, default False

    *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 Mask and how is it used in Blender Python scripting?

assistant: # Mask

This mode shows all the [masks](../../../movie_clip/masking/introduction.html) in the blend-file
(that have at least one layer) and lets you adjust their keyframes.

[image reference removed]

The Mask mode of the Dope Sheet Editor.
user: Show practical ways to work with Who uses Blender? in a Blender add-on or script – include code.

assistant: Blender has a wide variety of tools making it suitable for almost any sort of media production. Professionals,
hobbyists, and studios around the world use it for creating animations, game assets, motion graphics, TV shows,
concept art, story-boarding, commercials, and feature films.

Check out the [User Stories page](https://www.blender.org/get-involved/user-stories/)
on the Blender website for more examples.